code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
#ifndef _FX_TAG_MANAGER_H_SDILKJF408GY9435
#define _FX_TAG_MANAGER_H_SDILKJF408GY9435
#define FILENAME_TAGSCRIPT_LIST FILENAME_BASE TEXT ("TagScriptList.fxd")
#define FX_TS_MAX_ATK_LVL 3
#define FX_TS_MAX_DEF_LVL 3
#define FX_TS_MAX_MGK_LVL 3
#define FX_MAX_TAGSCRIPT 100
typedef enum
{
SIN_FUNC = 0,
COS_FUNC,
POS_FIXED
} FX_TS_FUNCTYPE;
typedef struct
{
FX_TS_FUNCTYPE func;
short scale;
float angle_mul;
} FX_TS_FUNC;
typedef enum
{
ALWAYS_LOOK_TGT = 0,
ALWAYS_LOOK_FWD,
ALWAYS_LOOK_CENTER,
FREE_LOOK
} FX_TS_LOOK;
typedef struct
{
char name [64];
int model;
vec3_t pos;
float velocity;
FX_TS_FUNC x_func;
FX_TS_FUNC y_func;
FX_TS_FUNC z_func;
char x_rotation;
char x_delay;
char y_rotation;
char y_delay;
char z_rotation;
char z_delay;
FX_TS_LOOK look;
int effect_atk [FX_TS_MAX_ATK_LVL];
int effect_def [FX_TS_MAX_DEF_LVL];
int effect_mgk [FX_TS_MAX_MGK_LVL];
} FX_TAGSCRIPT_t;
class CTagManager
{
public:
CTagManager();
virtual ~CTagManager();
protected:
stTAGINFO* m_aTagInfo;
INT m_iTagCount;
CScript *m_pScript;
int m_numTagScript;
FX_TAGSCRIPT_t m_tagScript [FX_MAX_TAGSCRIPT];
FX_CMathTbl *m_pMathTbl;
public:
bool Load ( TCHAR *strFilename );
int GetIndex ( char *pszMeshName );
char* GetParentName ( const int iTagIndex );
INT GetSize ();
TCHAR* GetName ( const INT iTagIndex );
void Cleanup ();
int LoadTagScript ();
int ParseScriptToken ( FX_TAGSCRIPT_t *in_script,
char *in_token );
char* ParseFuncScript ( FX_TS_FUNC *in_func );
char* ParseSubFuncScript ( FX_TS_FUNC *in_func, const bool in_isMinus );
int ScriptSearch ( char *in_name );
FX_TAGSCRIPT_t* GetScript ( int in_scriptID ) { return &m_tagScript [in_scriptID]; }
float GetDisplacement ( const FX_TS_FUNCTYPE in_functype, const int in_angle );
void SetMathTbl ( FX_CMathTbl *pMathTbl ) { m_pMathTbl = pMathTbl; }
void SetScript ( CScript *script ) { m_pScript = script; }
};
#endif | C++ |
#ifndef _FX_CHARACTER_SHADER_MANAGER_H_ASDIH9384GY
#define _FX_CHARACTER_SHADER_MANAGER_H_ASDIH9384GY
class FX_CCharShaderMng
{
public:
FX_CCharShaderMng ();
~FX_CCharShaderMng ();
public:
int m_iNumTexture;
Fx_TEX_BUF_t m_TexBuffer [MAX_COUNT_TEXTURE];
CHAR_SHADERREF_t m_shaderRefs [MAX_COUNT_TEXTURE];
int m_numEffectTexture;
char m_effectTexName [MAX_COUNT_EFFECT_TEXTURE][MAX_PATH];
CHAR_SHADERREF_t m_effectShaderRefs [MAX_COUNT_EFFECT_TEXTURE];
CD3DTextureMng *m_pTexMng;
CScript *m_pScript;
CShaderMng *m_shaderMng;
FX_CCharUtil *m_pCharUtil;
DWORD m_frameFlag;
public:
inline void SetScript ( CScript *script ) { m_pScript = script; };
inline void SetShaderMng ( CShaderMng *shaderMng ) { m_shaderMng = shaderMng; };
inline void SetTexManager ( CD3DTextureMng *texMng ) { m_pTexMng = texMng; };
inline void SetCharUtil ( FX_CCharUtil *charUtil ) { m_pCharUtil = charUtil; };
bool LoadTextureList ();
bool LoadEffectTextureList ();
int PrepareCharShaderLogin ();
int PrepareCharShaderCommon ();
int PrepareEffectShader ();
int SearchShaderRef ( char *in_name );
inline void PrepareShader ( int in_shaderIdx ) { m_shaderMng ->PrepareShader ( in_shaderIdx, m_frameFlag ); };
inline void PrepareShaderByRef ( int in_shaderIdx ) { PrepareShader ( GetShaderIdx ( in_shaderIdx ) ); };
inline void PrepareEffectShaderByRef( int in_effectIdx ) { PrepareShader ( GetEffectShaderIdx ( in_effectIdx ) ); };
inline void PrepareTimeShader ( int in_shaderIdx, float in_elapsedTime )
{ m_shaderMng ->PrepareShader ( in_shaderIdx, in_elapsedTime ); };
inline void PrepareTimeShaderByRef ( int in_shaderIdx, float in_elapsedTime )
{ PrepareTimeShader ( GetShaderIdx ( in_shaderIdx ), in_elapsedTime ); };
inline void PrepareTimeEffectShaderByRef( int in_effectIdx, float in_elapsedTime )
{ PrepareTimeShader ( GetEffectShaderIdx ( in_effectIdx ), in_elapsedTime ); };
inline void UpdateFrameFlag () { ++m_frameFlag; };
inline int CheckIsShader ( int in_shaderIdx ) { return m_shaderRefs [in_shaderIdx].isShader; };
inline int CheckIsEffectShader ( int in_effectIdx ) { return m_effectShaderRefs [in_effectIdx].isShader; }
inline int GetShaderIdx ( int in_shaderIdx ) { return m_shaderRefs [in_shaderIdx].shader; };
inline int GetEffectShaderIdx ( int in_effectIdx ) { return m_effectShaderRefs [in_effectIdx].shader; };
inline LPDIRECT3DTEXTURE8 GetD3DTextureByRef ( int in_shaderIdx ) { return m_pTexMng ->GetD3DTexture ( GetShaderIdx ( in_shaderIdx ) ); };
inline LPDIRECT3DTEXTURE8 GetD3DEffectTextureByRef( int in_effectIdx ) { return m_pTexMng ->GetD3DTexture ( GetEffectShaderIdx ( in_effectIdx ) ); };
inline shader_t* GetShader ( int in_shaderIdx ) { return &m_shaderMng ->m_shaders [in_shaderIdx]; };
inline shader_t* GetShaderByRef ( int in_shaderRef ) { return GetShader ( GetShaderIdx ( in_shaderRef ) ); };
inline shader_t* GetEffectShaderByRef( int in_shaderRef ) { return GetShader ( GetEffectShaderIdx ( in_shaderRef ) ); };
};
#endif | C++ |
#include "../../global_def.h"
#include "../Common.h"
#include "Mmsystem.h"
#define g_rotmatrix GLOBAL_DXMATRIX_1
#define g_resultMatrix GLOBAL_MATRIX_1
FX_CSkinManager::FX_CSkinManager ()
{
int i, j, k;
for ( int index = 0; \
index < MAX_COUNT_SKIN_PART; \
index++ )
m_meshOffset[index] = -1;
for( i = 0; i < NUM_GEN_TYPE; i ++ )
{
for( j = 0; j < MAX_COUNT_SKIN_PART; j ++ )
{
m_defSkinList[i].count[j] = 0;
for( k = 0; k < MAX_DEF_SKIN; k ++ )
m_defSkinList[i].list[j][k] = -1;
}
}
if ( g_resCounter->Enabled() )
{
g_resCounter->Add_DataType( RESCOUNTER_CHAR_SKINMANAGER, sizeof(FX_CSkinManager) );
}
}
bool FX_CSkinManager::LoadSkinList ()
{
int index, subindex;
UINT iRefID;
int errorval;
int oldcount;
m_iNumSkins = 0;
for ( index = 0; \
index < MAX_COUNT_SKIN_PART; \
++index )
{
switch ( index )
{
case SKIN_PART_HAIR:
errorval = m_pScript->Load ( FILENAME_SKIN_HAIR );
if ( ! errorval ) continue;
break;
case SKIN_PART_HEAD:
errorval = m_pScript->Load ( FILENAME_SKIN_HEAD );
if ( ! errorval ) continue;
break;
case SKIN_PART_UPPER:
errorval = m_pScript->Load ( FILENAME_SKIN_UPPER );
if ( ! errorval ) continue;
break;
case SKIN_PART_LOWER:
errorval = m_pScript->Load ( FILENAME_SKIN_LOWER );
if ( ! errorval ) continue;
break;
case SKIN_PART_HAND:
errorval = m_pScript->Load ( FILENAME_SKIN_HAND );
if ( ! errorval ) continue;
break;
case SKIN_PART_LEG:
errorval = m_pScript->Load ( FILENAME_SKIN_LEG );
if ( ! errorval ) continue;
break;
case SKIN_PART_FOOT:
errorval = m_pScript->Load ( FILENAME_SKIN_FOOT );
if ( ! errorval ) continue;
break;
case SKIN_PART_MONSTER:
errorval = m_pScript->Load ( FILENAME_SKIN_MONSTER );
if ( ! errorval ) continue;
break;
}
m_pScript->BeginParse ();
oldcount = m_iNumSkins;
m_meshOffset [index] = oldcount;
m_iNumSkins += atoi ( m_pScript->GetNextToken() );
for ( subindex = oldcount; \
subindex < m_iNumSkins; \
++subindex )
{
strcpy ( m_SkinBuffer [subindex].name,
m_pScript->GetNextToken() );
m_SkinBuffer [subindex].id = subindex;
sprintf ( m_SkinBuffer [subindex].texname,
"%s",
m_pScript->GetNextToken() );
iRefID = m_pCharShaderMng ->SearchShaderRef ( m_SkinBuffer [subindex].texname );
LoadSkin( m_SkinBuffer [subindex].name,
m_SkinBuffer [subindex].id,
iRefID );
m_Skins [subindex].partID = index;
}
}
return true;
}
void FX_CSkinManager::SetShaderMng ( CShaderMng *shaderMng )
{
m_shaderMng = shaderMng;
m_pSkinRenderer ->SetShaderMng ( shaderMng );
return;
}
void FX_CSkinManager::UpdateTextureID ()
{
for ( int index = 0; \
index < m_iNumSkins; \
++index )
{
m_Skins [ m_SkinBuffer [index].id ].iRefID
= m_pCharShaderMng ->SearchShaderRef ( m_SkinBuffer [index].texname );
}
}
bool FX_CSkinManager::LoadSkin ( char *pszSkinName,
const unsigned int &iSkinID,
const unsigned int &iRefID )
{
SKIN_t* pSkin;
pSkin = &m_Skins [iSkinID];
pSkin->mesh.LoadData ( pszSkinName,
m_fileMng );
pSkin->iRefID = iRefID;
return true;
}
void FX_CSkinManager::SetDevice ( LPDIRECT3DDEVICE8 device )
{
m_pd3dDevice = device;
m_pSkinRenderer->SetDevice ( m_pd3dDevice );
}
void FX_CSkinManager::SetTexManager ( CD3DTextureMng *texMng )
{
m_texMng = texMng;
}
void FX_CSkinManager::SetRenderer ( CD3DRender *d3dRender )
{
m_D3DRender = d3dRender;
m_pSkinRenderer ->SetRenderer ( d3dRender );
return;
}
bool FX_CSkinManager::PrepareRenderBuffers ()
{
m_pSkinRenderer->CreateBuffers();
return true;
}
bool FX_CSkinManager::ReleaseRenderBuffers ()
{
m_pSkinRenderer ->ReleaseBuffers();
return true;
}
bool FX_CSkinManager::RenderAllNormal ( int *in_numprims )
{
SKIN_t *pThisSkin;
CHAR_BUFFER_t *pCharBuffer;
int iRefIndex;
KEYFRAME *pKeyFrames;
Fx_CHARACTER_t *pCharacter;
extern Fx_CHARACTER_t *g_mouseSelectedCharacter;
int index;
int forceUpdate = m_pCharManager ->GetForceUpdateSkin ();
#ifdef _FX_CLIENT
Fx_CHARACTER_t *pTargetChar = NULL;
if ( g_cgv.state == CLIENT_GAME_PROCESS )
{
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar == NULL )
pTargetChar = g_mouseSelectedCharacter;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar == NULL )
pTargetChar = NULL;
}
else
pTargetChar = g_mouseSelectedCharacter;
#endif
m_pSkinRenderer ->PrepareRender ();
for ( index = 0;
index < m_iNumMeshInBuffer;
++index )
{
pCharBuffer = &m_CharBuffer [index];
pThisSkin = &m_Skins[ pCharBuffer->meshID ];
iRefIndex = pThisSkin ->iRefID;
SetTextureByRef ( iRefIndex );
for ( int subindex = 0; \
subindex < pCharBuffer->count; \
++subindex )
{
pCharacter = pCharBuffer->characterPtr [subindex];
if ( pCharacter->isCreature )
{
int aaa = 0;
}
if ( pCharacter ->flag_disappear ) continue;
if ( ! pCharacter->ren_renderThisFrame ) continue;
m_pSkinRenderer->SetStreamSource( pCharacter, 0 );
if ( ! pCharacter->isCreature &&
pCharacter->ID == 0 )
m_pCharManager ->ApplyCharacterColorChanging( pCharacter );
if ( m_pCharManager->CheckSkinUpdateTime( pCharacter ) ||
forceUpdate ||
pCharacter->flag_forceUpdate )
{
pKeyFrames = pCharacter ->key_resultFrames;
m_pSkinRenderer->TransformMesh ( pCharacter,
&pThisSkin->mesh,
pKeyFrames,
GetNumVertex( pCharacter->stat_skinID [pThisSkin ->partID], pCharacter->stat_LODLevel ),
pThisSkin->partID );
m_pSkinRenderer ->SetIndices ( pCharacter,
pThisSkin->mesh.m_meshes[ pCharacter->stat_LODLevel ].meshchunk->faceLists,
pThisSkin->mesh.m_meshes[ pCharacter->stat_LODLevel ].meshchunk->iNumFace,
pThisSkin->partID );
}
m_D3DRender ->SetIndices( m_pSkinRenderer->GetIndexBuffer( pCharacter ), 0L );
#ifdef _FX_CLIENT
if ( ( pTargetChar != pCharacter ) ||
( ( pCharacter ->entityType != ENTITY_PC ) &&
( pCharacter ->stat_alive > MON_ALIVE_STATE_CORPSE ) ) )
#else
if ( true )
#endif
{
if ( m_pCharShaderMng ->CheckIsShader ( iRefIndex ) )
{
if ( pCharacter->cr_inUse )
{
matrix4x4_t *mat_world = m_pCharManager->m_pItemManager->GetTagMatrixOut( pCharacter->cr_creature, ITEM_PART_CREATURE_TYPE_0 );
if ( ! mat_world )
continue;
m_D3DRender->SetTransform( D3DTS_WORLD, mat_world );
}
else
{
m_D3DRender->SetTransform( D3DTS_WORLD, &pCharacter->stat_matTransform );
}
m_pSkinRenderer->ShaderRender( pCharacter, m_pCharShaderMng->GetShaderIdx( iRefIndex ), in_numprims, pThisSkin->partID );
}
else
{
if ( pCharacter->cr_inUse )
{
matrix4x4_t *mat_world = m_pCharManager->m_pItemManager->GetTagMatrixOut( pCharacter->cr_creature, ITEM_PART_CREATURE_TYPE_0 );
if ( ! mat_world )
continue;
m_D3DRender->SetTransform( D3DTS_WORLD, mat_world );
}
else
{
m_D3DRender->SetTransform( D3DTS_WORLD, &pCharacter->stat_matTransform );
}
m_pSkinRenderer->Render( pCharacter, in_numprims, pThisSkin->partID );
}
}
else
{
if ( pCharacter->cr_inUse )
{
matrix4x4_t *mat_world = m_pCharManager->m_pItemManager->GetTagMatrixOut( pCharacter->cr_creature, ITEM_PART_CREATURE_TYPE_0 );
if ( ! mat_world )
continue;
m_D3DRender->SetTransform( D3DTS_WORLD, mat_world );
}
else
{
m_D3DRender->SetTransform( D3DTS_WORLD, &pCharacter->stat_matTransform );
}
if ( m_pCharShaderMng ->CheckIsShader ( iRefIndex ) )
{
m_pSkinRenderer->ShaderRender( pCharacter, m_pCharShaderMng->GetShaderIdx( iRefIndex ), in_numprims, pThisSkin->partID );
}
else
{
m_pSkinRenderer->Render( pCharacter, in_numprims, pThisSkin->partID );
}
}
if ( ! pCharacter->isCreature &&
pCharacter->ID == 0 )
m_pCharManager ->RestoreCharacterColorChanging( pCharacter );
}
}
return true;
}
#ifdef _FX_CLIENT
bool FX_CSkinManager::RenderAllDisappear ( int *in_numprims )
{
SKIN_t *pThisSkin;
CHAR_BUFFER_t *pCharBuffer;
int iRefIndex;
KEYFRAME *pKeyFrames;
Fx_CHARACTER_t *pCharacter;
extern Fx_CHARACTER_t *g_mouseSelectedCharacter;
int index;
int forceUpdate = m_pCharManager ->GetForceUpdateSkin ();
bool flag_disappear;
Fx_CHARACTER_t *pTargetChar = NULL;
if ( g_cgv.state == CLIENT_GAME_PROCESS )
{
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar == NULL )
pTargetChar = g_mouseSelectedCharacter;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar == NULL )
pTargetChar = NULL;
}
else
pTargetChar = g_mouseSelectedCharacter;
m_pSkinRenderer ->PrepareRender ();
for ( index = 0;
index < m_iNumMeshInBuffer;
++index )
{
pCharBuffer = &m_CharBuffer [index];
pThisSkin = &m_Skins[ pCharBuffer->meshID ];
iRefIndex = pThisSkin ->iRefID;
flag_disappear = false;
SetTextureByRef ( iRefIndex );
for ( int subindex = 0; \
subindex < pCharBuffer->count; \
++subindex )
{
pCharacter = pCharBuffer->characterPtr [subindex];
if ( ! pCharacter ->flag_disappear ) continue;
if ( ! pCharacter ->flag_disappearSound )
{
pCharacter ->flag_disappearSound = true;
}
if ( ! pCharacter->ren_renderThisFrame ) continue;
m_pSkinRenderer->SetStreamSource( pCharacter, 0 );
if ( ! pCharacter ->flag_appTimeStamped )
{
g_effectMng ->Add ( GTH_EFFECT_CLASS_MODEL , 8 , pCharacter ->position , NULL , pCharacter ->angles , 0.0f , pCharacter ->entityType , pCharacter ->idxOnServer );
pCharacter ->ren_stampedAppTime = g_timer.m_currSysTime;
pCharacter ->flag_appTimeStamped = true;
}
m_pCharShaderMng ->PrepareTimeEffectShaderByRef ( CHAR_SHADER_MONSTER_DEAD_1, (g_timer .m_currSysTime - pCharacter ->ren_stampedAppTime) );
flag_disappear = true;
if ( m_pCharManager->CheckSkinUpdateTime( pCharacter ) ||
forceUpdate ||
pCharacter->flag_forceUpdate )
{
pKeyFrames = pCharacter ->key_resultFrames;
m_pSkinRenderer->TransformMesh ( pCharacter,
&pThisSkin ->mesh,
pKeyFrames,
GetNumVertex( pCharacter->stat_skinID[ pThisSkin->partID ], pCharacter->stat_LODLevel ),
pThisSkin->partID );
m_pSkinRenderer ->SetIndices( pCharacter,
pThisSkin->mesh.m_meshes[ pCharacter->stat_LODLevel ].meshchunk->faceLists,
pThisSkin->mesh.m_meshes[ pCharacter->stat_LODLevel ].meshchunk->iNumFace,
pThisSkin->partID );
}
m_D3DRender->SetIndices( m_pSkinRenderer->GetIndexBuffer( pCharacter ), 0L );
if ( ( pTargetChar != pCharacter ) ||
( ( pCharacter ->entityType != ENTITY_PC ) &&
( pCharacter ->stat_alive > MON_ALIVE_STATE_CORPSE ) ) )
{
float modifier = (g_timer .m_currSysTime - pCharacter ->ren_stampedAppTime) + 1.0f;
GLOBAL_SCALEMATRIX.a00 = GLOBAL_SCALEMATRIX.a11 = 1.0f / modifier;
GLOBAL_SCALEMATRIX.a22 = modifier;
modifier = (modifier - 1.0f) * 2.0f;
D3DXMatrixRotationZ ( (D3DXMATRIX *)&g_rotmatrix, modifier );
modifier *= 10.0f;
pCharacter ->stat_matTransform.a23 += modifier;
D3DXMatrixMultiply ( (D3DXMATRIX *)&g_resultMatrix, (D3DXMATRIX *)&GLOBAL_SCALEMATRIX, (D3DXMATRIX *)&g_rotmatrix );
D3DXMatrixMultiply ( (D3DXMATRIX *)&g_resultMatrix, (D3DXMATRIX *)&g_resultMatrix, (D3DXMATRIX *)&pCharacter ->stat_matTransform );
m_D3DRender ->SetTransform ( D3DTS_WORLD, &g_resultMatrix );
pCharacter ->stat_matTransform.a23 -= modifier;
m_pSkinRenderer->ShaderRender( pCharacter, m_pCharShaderMng->GetEffectShaderIdx( CHAR_SHADER_MONSTER_DEAD_1 ), in_numprims, pThisSkin->partID );
}
}
}
return true;
}
#endif
bool FX_CSkinManager::SetRenderState ()
{
return true;
}
bool FX_CSkinManager::UpdateCharBuffer ()
{
for ( int index = 0;
index < MAX_COUNT_SKIN_MESH;
++index )
{
m_iBufferIndexMap [index] = -1;
}
m_iNumMeshInBuffer = 0;
Fx_CHARACTER_t *pCharacter;
int iSkinID;
CHAR_BUFFER_t *pCharBuffer;
for ( index = 0; \
index < m_pCharManager->m_iNumCharacters; \
++index )
{
pCharacter = &m_pCharManager->m_Characters [index];
for ( int subindex = 0;
subindex < MAX_COUNT_SKIN_PART;
++subindex )
{
iSkinID = pCharacter->stat_skinID [subindex];
if ( iSkinID == -1 )
continue;
if ( m_iBufferIndexMap [iSkinID] == -1 )
{
m_iBufferIndexMap [iSkinID] = m_iNumMeshInBuffer;
pCharBuffer = &m_CharBuffer [m_iNumMeshInBuffer];
pCharBuffer->meshID = iSkinID;
pCharBuffer->count = 1;
pCharBuffer->characterPtr[ 0 ] = pCharacter;
++m_iNumMeshInBuffer;
}
else
{
pCharBuffer = &m_CharBuffer [m_iBufferIndexMap [iSkinID]];
++(pCharBuffer->count);
pCharBuffer->characterPtr[ pCharBuffer->count - 1 ] = pCharacter;
}
}
}
ITOR_LIST_CREATURE itor;
for ( itor = m_pCharManager->m_usedCreatureList.begin(); \
itor != m_pCharManager->m_usedCreatureList.end(); \
++itor )
{
pCharacter = (*itor);
for ( int subindex = 0;
subindex < MAX_COUNT_SKIN_PART;
++subindex )
{
iSkinID = pCharacter->stat_skinID [subindex];
if ( iSkinID == -1 )
continue;
if ( m_iBufferIndexMap [iSkinID] == -1 )
{
m_iBufferIndexMap [iSkinID] = m_iNumMeshInBuffer;
pCharBuffer = &m_CharBuffer [m_iNumMeshInBuffer];
pCharBuffer->meshID = iSkinID;
pCharBuffer->count = 1;
pCharBuffer->characterPtr[ 0 ] = pCharacter;
++m_iNumMeshInBuffer;
}
else
{
pCharBuffer = &m_CharBuffer [m_iBufferIndexMap [iSkinID]];
++(pCharBuffer->count);
pCharBuffer->characterPtr[ pCharBuffer->count - 1 ] = pCharacter;
}
}
}
return true;
}
void FX_CSkinManager::Cleanup ()
{
for ( int index = 0;
index < m_iNumSkins;
++index )
{
m_Skins [index] .mesh .Cleanup();
}
m_pSkinRenderer->Cleanup();
GTH_SAFE_DELETE ( m_pSkinRenderer );
return;
}
int FX_CSkinManager::MakeSkinID ( const int in_type,
const int in_internalID )
{
if( in_internalID < 0 ) return( -1 );
else return m_meshOffset [in_type] + in_internalID;
}
void FX_CSkinManager::SplitSkinID ( const int in_skinID,
int &out_type,
int &out_internalID )
{
for ( int index = 0; \
index < MAX_COUNT_SKIN_PART; \
++index )
{
if ( m_meshOffset [index] < in_skinID )
continue;
break;
}
out_type = index - 1;
out_internalID = in_skinID - m_meshOffset [out_type];
return;
}
void FX_CSkinManager::SetSkelManager ( FX_CSkelManager *skelManager )
{
m_pSkelManager = skelManager;
m_pSkinRenderer ->SetSkelManager ( m_pSkelManager );
return;
}
int FX_CSkinManager::LoadDefSkinList ()
{
char *token;
memset ( m_defSkinList, 0, sizeof (m_defSkinList) );
m_pScript ->Load ( FILENAME_SKINDFT_LIST );
m_pScript ->BeginParse ();
while ( 1 )
{
token = m_pScript ->GetNextToken ( true );
if ( ! token [0] ) break;
if ( token [0] != '{' ) continue;
while ( 1 )
{
token = m_pScript ->GetNextToken ( true );
if ( ! token [0] ) break;
if ( token [0] == '}' ) break;
ParseSubDefSkinList ( token );
}
}
return true;
}
int FX_CSkinManager::ParseSubDefSkinList ( char *in_token )
{
static int gen_type;
char *token;
if ( 0 == _stricmp ( in_token, "gen_type" ) )
{
token = m_pScript ->GetNextToken ( true );
if ( 0 == _stricmp ( token, "mentality" ) )
{
gen_type = GEN_TYPE_SPIRIT;
}
else if ( 0 == _stricmp ( token, "wind" ) )
{
gen_type = GEN_TYPE_WIND;
}
else if ( 0 == _stricmp ( token, "water" ) )
{
gen_type = GEN_TYPE_WATER;
}
else if ( 0 == _stricmp ( token, "earth" ) )
{
gen_type = GEN_TYPE_SOIL;
}
else if ( 0 == _stricmp ( token, "poison" ) )
{
gen_type = GEN_TYPE_POISON;
}
else if ( 0 == _stricmp ( token, "iron" ) )
{
gen_type = GEN_TYPE_IRON;
}
else if ( 0 == _stricmp ( token, "fire" ) )
{
gen_type = GEN_TYPE_FIRE;
}
else if ( 0 == _stricmp ( token, "body" ) )
{
gen_type = GEN_TYPE_BODY;
}
}
else if ( 0 == _stricmp ( in_token, "hair" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_HAIR], m_defSkinList [gen_type].count [SKIN_PART_HAIR] );
}
else if ( 0 == _stricmp ( in_token, "head" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_HEAD], m_defSkinList [gen_type].count [SKIN_PART_HEAD] );
}
else if ( 0 == _stricmp ( in_token, "upper" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_UPPER], m_defSkinList [gen_type].count [SKIN_PART_UPPER] );
}
else if ( 0 == _stricmp ( in_token, "lower" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_LOWER], m_defSkinList [gen_type].count [SKIN_PART_LOWER] );
}
else if ( 0 == _stricmp ( in_token, "hand" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_HAND], m_defSkinList [gen_type].count [SKIN_PART_HAND] );
}
else if ( 0 == _stricmp ( in_token, "leg" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_LEG], m_defSkinList [gen_type].count [SKIN_PART_LEG] );
}
else if ( 0 == _stricmp ( in_token, "foot" ) )
{
ParseNextLevel ( m_defSkinList [gen_type].list [SKIN_PART_FOOT], m_defSkinList [gen_type].count [SKIN_PART_FOOT] );
}
return true;
}
int FX_CSkinManager::ParseNextLevel ( int *out_list,
int &out_count )
{
char *token;
token = m_pScript ->GetNextToken ( true );
if ( token [0] != '{' ) return -1;
out_count = 0;
while ( 1 )
{
token = m_pScript ->GetNextToken ( true );
if ( token [0] == '}' ) break;
out_list [out_count++] = atoi ( token );
}
return true;
}
void FX_CSkinManager::GetDefaultSkin ( const int in_gentype,
const int in_type,
int *out_list,
int &out_count )
{
out_count = m_defSkinList [in_gentype].count [in_type];
for ( int index = 0; \
index < out_count; \
++index )
{
out_list [index] = m_defSkinList [in_gentype].list [in_type][index];
}
return;
}
int FX_CSkinManager::GetDefaultSkinID ( const int in_gentype,
const int in_type,
const int idx )
{
if( m_defSkinList[in_gentype].count[in_type] == 0 ) return( -1 );
return( m_defSkinList[in_gentype].list[in_type][idx] );
}
int FX_CSkinManager::GetNumVertex ( const int in_skinID,
const int in_LODLevel )
{
return m_Skins [in_skinID].mesh.m_meshes [in_LODLevel].meshchunk ->iNumVertexMap;
}
int FX_CSkinManager::GetNumIndex ( const int in_skinID,
const int in_LODLevel )
{
return (m_Skins [in_skinID].mesh.m_meshes [in_LODLevel].meshchunk ->iNumFace * 3);
}
void FX_CSkinManager::SetTextureByRef ( int in_ref )
{
if ( m_pCharShaderMng ->CheckIsShader ( in_ref ) )
{
m_pCharShaderMng ->PrepareShaderByRef ( in_ref );
}
else
{
m_D3DRender ->SetTexture ( 0, m_pCharShaderMng ->GetD3DTextureByRef ( in_ref ) );
}
}
void FX_CSkinManager::DiscardAllIndexBuffers ()
{
int index;
Fx_CHARACTER_t *thisChar = &m_pCharManager->m_Characters[0];
for ( index = 0; \
index < MAX_CHAR_A_SCENE; \
++index, ++thisChar )
{
m_pSkinRenderer->DiscardIndexBuffer( thisChar );
}
}
void FX_CSkinManager::DiscardIndexBuffer ( Fx_CHARACTER_t *in_char )
{
m_pSkinRenderer->DiscardIndexBuffer( in_char );
}
void FX_CSkinManager::DiscardVertexBuffer ( Fx_CHARACTER_t *in_char )
{
m_pSkinRenderer->DiscardVertexBuffer( in_char );
}
void FX_CSkinManager::DiscardAllVertexBuffers ()
{
int index;
Fx_CHARACTER_t *thisChar = &m_pCharManager->m_Characters[0];
for ( index = 0; \
index < MAX_CHAR_A_SCENE; \
++index )
{
m_pSkinRenderer->DiscardVertexBuffer( thisChar );
}
} | C++ |
#include "../../global_def.h"
#include "../Common.h"
FX_CSkelManager::FX_CSkelManager ()
{
memset ( m_iBoneLookUp,
-1,
sizeof(int) * MAX_COUNT_SKEL * MAX_COUNT_BONE );
}
bool FX_CSkelManager::LoadSkelList ()
{
m_pScript->Load ( FILENAME_SKEL_LIST );
m_pScript->BeginParse();
m_iNumSkels = atoi ( m_pScript->GetNextToken() );
for ( int index = 0;
index < m_iNumSkels;
++index )
{
strcpy ( m_SkelBuffer [index].name,
m_pScript->GetNextToken() );
m_SkelBuffer [index].id = atoi ( m_pScript->GetNextToken() );
LoadSkel ( m_SkelBuffer [index].name,
m_SkelBuffer [index].id );
}
return true;
}
bool FX_CSkelManager::LoadSkel( char *pszSkelName,
unsigned int &iSkelID )
{
SKELETON_t *pSkel;
pSkel = &m_Skels [iSkelID];
pSkel->skeleton.LoadData ( pszSkelName,
m_fileMng );
return true;
}
void FX_CSkelManager::Cleanup ()
{
for ( int index = 0;
index < m_iNumSkels;
++index )
{
m_Skels [index] .skeleton .Cleanup();
}
return;
}
void FX_CSkelManager::MakeLookupTable ()
{
for ( int index = 0;
index < m_iNumSkels;
++index )
{
for ( int subindex = 0;
subindex < m_pBoneManager->m_iBoneCount;
++subindex )
{
m_iBoneLookUp [index][subindex] = GetLocalID ( subindex,
index );
}
}
return;
}
int FX_CSkelManager::GetLocalID ( const int iGlobalID,
const int iBoneID )
{
char *pszBoneName;
FX_CSkel *pThisBone = &m_Skels [iBoneID] .skeleton;
pszBoneName = m_pBoneManager->GetName ( iGlobalID );
for ( int index = 0;
index < pThisBone->m_iNumBone;
++index )
{
if ( 0 == stricmp ( pszBoneName, pThisBone ->m_pBones [index].strBoneName ) )
{
return index;
}
}
return -1;
}
| C++ |
#include "../../global_def.h"
#include "../Common.h"
FX_CCharShaderMng::FX_CCharShaderMng ()
{
memset ( m_shaderRefs, 0, sizeof(m_shaderRefs) );
m_frameFlag = 0;
}
FX_CCharShaderMng::~FX_CCharShaderMng ()
{
}
bool FX_CCharShaderMng::LoadTextureList ()
{
int result;
result = m_pScript ->Load ( FILENAME_TEX_LIST );
#ifdef _FXDEBUG
CHECKERROR ( ! result, "Failed to load texture list file! Check filename!" )
#endif
m_pScript ->BeginParse ();
m_iNumTexture = atoi ( m_pScript ->GetNextToken() );
for ( int index = 0; \
index < m_iNumTexture; \
++index )
{
strcpy ( m_TexBuffer [index].name,
m_pScript ->GetNextToken () );
}
if ( g_cgv.currentWorldIdx < 0 )
{
PrepareCharShaderLogin ();
}
else
{
PrepareCharShaderCommon ();
}
return true;
}
bool FX_CCharShaderMng::LoadEffectTextureList ()
{
int result;
result = m_pScript ->Load ( FILENAME_EFFECT_TEX_LIST );
#ifdef _FXDEBUG
CHECKERROR ( ! result, "Failed to load effect-texture list file! Check filename!" )
#endif
m_pScript ->BeginParse ();
m_numEffectTexture = atoi ( m_pScript ->GetNextToken() );
for ( int index = 0; \
index < m_numEffectTexture; \
++index )
{
strcpy ( m_effectTexName [index],
m_pScript ->GetNextToken () );
}
PrepareEffectShader ();
return true;
}
int FX_CCharShaderMng::PrepareCharShaderLogin ()
{
int i, idxShader;
shader_t *shader;
CHAR_SHADERREF_t *shaderRef;
char shaderName [256];
for ( i = 0; \
i < m_iNumTexture; \
i++ )
{
if ( strstr ( m_TexBuffer [i].name, "skin/monster/mol/" ) )
{
}
else if ( strstr ( m_TexBuffer [i].name, "skin/monster" ) ||
strstr ( m_TexBuffer [i].name, "skin/npc" ) )
{
continue;
}
m_pCharUtil ->RemoveExtension ( m_TexBuffer [i].name, shaderName );
shaderRef = &m_shaderRefs [i];
strcpy ( shaderRef ->name, shaderName );
idxShader = m_shaderMng ->SearchShader ( shaderName );
if ( idxShader < 0 )
{
shaderRef ->shader = m_pTexMng ->Add ( shaderName,
OWNER_TYPE_CHARACTER );
shaderRef ->surfaceFlags = 0;
shaderRef ->isShader = false;
continue;
}
m_shaderMng ->InitShader ( idxShader );
shader = m_shaderMng ->GetShader ( idxShader );
shaderRef ->shader = idxShader;
shaderRef ->surfaceFlags = shader ->flags;
shaderRef ->isShader = true;
}
return true;
}
int FX_CCharShaderMng::PrepareCharShaderCommon ()
{
int index, subindex;
int idxShader;
shader_t *shader;
CHAR_SHADERREF_t *shaderRef;
char shaderName [256];
int monsterIdx = -1;
bool flag = false;
int numMonsterKind = g_pApp ->m_mapInfos [0].monsterKind;
unsigned short *monsterKind = g_pApp ->m_mapInfos [0].monsters;
for ( index = 0; \
index < m_iNumTexture; \
index++ )
{
if ( strstr ( m_TexBuffer [index].name, "skin/monster" ) ||
strstr ( m_TexBuffer [index].name, "skin/npc" ) )
{
monsterIdx += 1;
bool found = false;
for ( subindex = 0; \
subindex < numMonsterKind; \
++subindex )
{
if ( monsterIdx == g_monsterTable [(int)monsterKind [subindex]].modelID )
{
found = true;
break;
}
}
if ( ! found ) continue;
}
m_pCharUtil ->RemoveExtension ( m_TexBuffer [index].name, shaderName );
shaderRef = &m_shaderRefs [index];
strcpy ( shaderRef ->name, shaderName );
idxShader = m_shaderMng ->SearchShader ( shaderName );
if ( idxShader < 0 )
{
shaderRef ->shader = m_pTexMng ->Add ( shaderName,
OWNER_TYPE_CHARACTER );
shaderRef ->surfaceFlags = 0;
shaderRef ->isShader = false;
continue;
}
m_shaderMng ->InitShader ( idxShader );
shader = m_shaderMng ->GetShader ( idxShader );
shaderRef ->shader = idxShader;
shaderRef ->surfaceFlags = shader ->flags;
shaderRef ->isShader = true;
}
return true;
}
int FX_CCharShaderMng::PrepareEffectShader ()
{
int index, idxShader;
shader_t *shader;
CHAR_SHADERREF_t *shaderRef;
char shaderName [256];
for ( index = 0; \
index < m_numEffectTexture; \
index++ )
{
m_pCharUtil ->RemoveExtension ( m_effectTexName [index], shaderName );
shaderRef = &m_effectShaderRefs [index];
#ifdef _FXDEBUG
strcpy ( shaderRef ->name, shaderName );
#endif
idxShader = m_shaderMng ->SearchShader ( shaderName );
if ( idxShader < 0 )
{
shaderRef ->shader = m_pTexMng ->Add ( shaderName,
OWNER_TYPE_CHARACTER );
shaderRef ->surfaceFlags = 0;
shaderRef ->isShader = false;
continue;
}
m_shaderMng ->InitShader ( idxShader );
shader = m_shaderMng ->GetShader ( idxShader );
shaderRef ->shader = idxShader;
shaderRef ->surfaceFlags = shader ->flags;
shaderRef ->isShader = true;
}
return true;
}
int FX_CCharShaderMng::SearchShaderRef ( char *in_name )
{
int index;
for ( index = 0; \
index < m_iNumTexture; \
++index )
{
if ( stricmp ( in_name, m_TexBuffer [index].name ) == 0 )
return index;
}
return 0;
} | C++ |
#ifndef _ANIMATION_MANAGER_H_FJ109R081HE0812
#define _ANIMATION_MANAGER_H_FJ109R081HE0812
typedef struct
{
FX_CAnim animation;
int inUse;
} ANIMATION_t;
#define MAX_DAMAGE_FRAMES 10
#pragma warning( disable : 4800 )
typedef struct ATTACKMOTIONINFO
{
WORD used;
WORD combocount;
WORD startframes [MAX_DAMAGE_FRAMES];
WORD damageframes [MAX_DAMAGE_FRAMES];
WORD freeframes [MAX_DAMAGE_FRAMES];
WORD aurastart;
WORD auraend;
WORD skill;
WORD showAttackEffect;
WORD showAttackAura;
WORD reserved [11];
inline bool IsComboAttack () { return (bool)used; }
inline WORD GetComboCount () { return combocount; }
inline WORD GetAuraStartFrame () { return aurastart; }
inline WORD GetAuraEndFrame () { return auraend; }
inline WORD GetStartFrame ( int in_frameIdx );
inline WORD GetDamageFrame ( int in_frameIdx );
inline WORD GetFreeFrame ( int in_frameIdx );
inline WORD GetAttackFrame ( int in_frameIdx );
inline bool IsSkillAttack () { return (bool)skill; }
inline bool ShowAttackEffect () { return (bool)showAttackEffect; }
inline bool ShowAttackAura () { return (bool)showAttackAura; }
inline void SetIsComboAttack ( bool in_isComboAttack ) { used = in_isComboAttack; }
inline void SetComboCount ( WORD in_comboCount ) { combocount = in_comboCount; }
inline void SetAuraStartFrame ( WORD in_auraStartFrame ) { aurastart = in_auraStartFrame; }
inline void SetAuraEndFrame ( WORD in_auraEndFrame ) { auraend = in_auraEndFrame; }
inline void SetStartFrame ( int in_frameIdx, WORD in_startFrame );
inline void SetDamageFrame ( int in_frameIdx, WORD in_damageFrame );
inline void SetFreeFrame ( int in_frameIdx, WORD in_freeFrame );
inline void SetIsSkillAttack ( bool in_isSkillAttack ) { skill = in_isSkillAttack; }
inline void SetShowAttackEffect ( bool in_showAttackEffect ) { showAttackEffect = in_showAttackEffect; }
inline void SetShowAttackAura ( bool in_showAttackAura ) { showAttackAura = in_showAttackAura; }
} ATTACKMOTIONINFO_t;
class CParamBlock_CalcFreeTime
{
private:
int animIndex;
float desiredTime;
int currentComboCount;
public:
inline void SetAnimIndex ( int in_animIndex );
inline void SetDesiredTime ( float in_desiredTime );
inline void SetCurrentComboCount ( float in_currentComboCount );
inline int GetAnimIndex () { return animIndex; }
inline float GetDesiredTime () { return desiredTime; }
inline int GetCurrentComboCount() { return currentComboCount; }
};
class FX_CAnimManager
{
public:
FX_CAnimManager();
~FX_CAnimManager() {};
public:
ANIMATION_t m_Anims [MAX_COUNT_ANIM];
int m_iNumAnims;
KEYFRAME *m_pCurKeyframe;
Fx_ANIM_BUF_t m_AnimBuffer [MAX_COUNT_ANIM];
CScript *m_pScript;
CFileMng *m_fileMng;
int m_notUsedMonAnims[ MAX_COUNT_ANIM ];
int m_numNotUsedMonAnims;
public:
bool LoadAnimList();
void Cleanup();
void SetScript ( CScript *script ) { m_pScript = script; }
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
void GetBoundBox ( Fx_CHARACTER_t *in_char, int in_frame, bboxf_t &out_boundbox );
private:
bool LoadAnim ( char *pszFileName, const unsigned int &iAnimID );
protected:
ATTACKMOTIONINFO_t m_attackMotionInfos [MAX_COUNT_ANIM];
int m_AMInfoVersion;
public:
bool LoadAMInfos ();
inline int GetComboCount ( int in_animIndex );
inline int GetDamageFrame ( int in_animIndex, int in_comboIndex );
inline int GetFreeFrame ( int in_animIndex, int in_comboIndex );
inline int GetAuraStartFrame ( int in_animIndex );
inline int GetAuraEndFrame ( int in_animIndex );
inline int GetStartFrame ( int in_animIndex, int in_comboIndex );
inline int GetAttackFrame ( int in_animIndex, int in_comboIndex );
inline int IsComboAttack ( int in_animIndex );
inline int IsSkillAttack ( int in_animIndex );
inline int ShowAttackEffect ( int in_animIndex );
inline int ShowAttackAura ( int in_animIndex );
float CalcFreeTime ( CParamBlock_CalcFreeTime &in_paramBlock );
inline ATTACKMOTIONINFO_t& GetAttackMotionInfo ( int in_motionIndex );
inline float CalcAttackTimeInplace ( CParamBlock_CalcFreeTime &in_paramBlock );
inline float CalcAllPartialFreeFrames ( CParamBlock_CalcFreeTime &in_paramBlock );
int FindAnimIndexInAnimBuffer ( char *in_animName );
float CalcAttackSpeedRatio ( int in_animIndex, float in_desiredTime );
float CalcFreeTimeVariable ( int in_animIndex, float in_desiredTime );
void CalcAttackTime ( int in_animIndex, float in_totalTime, int *in_timeList );
void LoadActualData ();
};
#include "AnimationManager.inl"
#endif | C++ |
#ifdef _FX_TOOL
#include "../../global_def.h"
#include "../Common.h"
int FX_CCharManager::CheckCorrectBone ( Fx_CHARACTER_t *pThisChar )
{
FX_CSkel *pSkel;
FX_CAnim *pAnim;
int aniID;
if ( pThisChar ->attr_skelID < 0 ) return false;
pSkel = &m_pSkelManager ->m_Skels [pThisChar ->attr_skelID].skeleton;
aniID = m_pCharLookupMng ->GetAnimIDFromTable ( pThisChar ->entityType, pThisChar ->tableIdx,
pThisChar ->ani_curSetType, pThisChar ->ani_curItemSetIndex, pThisChar ->ani_curSetID, pThisChar->ID );
if( aniID < 0 || aniID >= MAX_COUNT_ANIM )
return false;
pAnim = &m_pAnimManager ->m_Anims [aniID].animation;
if ( ! ( pSkel ->m_pBoneStID.sub [0] == pAnim ->m_pBoneStID.sub [0] &&
pSkel ->m_pBoneStID.sub [1] == pAnim ->m_pBoneStID.sub [1] &&
pSkel ->m_pBoneStID.sub [2] == pAnim ->m_pBoneStID.sub [2] &&
pSkel ->m_pBoneStID.sub [3] == pAnim ->m_pBoneStID.sub [3] ) )
return false;
return true;
}
void FX_CCharManager::GenerateAniToolsCharacter ( int entityType,
int skinIdx,
int aniIdx )
{
Fx_CHARACTER_t *pNewChar;
int i;
pNewChar = &m_Characters [0];
m_iNumCharacters = 1;
pNewChar ->position [0] = 0.0f;
pNewChar ->position [1] = 0.0f;
pNewChar ->position [2] = 0.0f;
pNewChar ->ID = 0;
pNewChar ->flag_interpolation = false;
pNewChar ->useInterpolation = false;
pNewChar ->ani_elapsed = 0.0f;
pNewChar ->ani_oldFrame = 0.0f;
pNewChar ->ani_curIdx = m_pCharLookupMng ->GetIdleAnimation ( 0, 0, 0, 0 );
pNewChar ->ani_nextIdx = -1;
pNewChar ->ani_curState.type.changable = true;
pNewChar ->ani_curState.type.repeatable = true;
pNewChar ->ani_curState.type.movable = true;
pNewChar ->ani_curState.type.alive = true;
pNewChar ->ani_curGroup = FX_ANIM_GROUP_MOVE;
pNewChar ->ani_nextGroup = FX_ANIM_GROUP_NULL;
pNewChar ->oldEvent = GTH_EV_CHAR_IDLE;
pNewChar ->attr_skelID = -1;
pNewChar ->stat_scale = 1.0f;
if ( entityType == ENTITY_PC )
{
pNewChar ->entityType = ENTITY_PC;
pNewChar ->tableIdx = aniIdx;
pNewChar ->skinPart [0] = 0;
pNewChar ->skinPart [1] = 0;
pNewChar ->skinPart [2] = 0;
pNewChar ->skinPart [3] = 0;
SetDefaultCharacter ( 0 );
InitNewChar ( pNewChar );
pNewChar ->ani_curSpeed = 1.0f;
pNewChar ->ani_curRSpeed = 1.0f / pNewChar ->ani_curSpeed;
pNewChar ->ani_option = ANIMOPTION_START_NEW_ANIM;
CheckAuraExist ( 0 );
pNewChar ->attr_skelID = m_pCharLookupMng ->GetBoneIDFromTable ( pNewChar ->entityType, pNewChar ->tableIdx );
}
else if ( entityType == ENTITY_MONSTER )
{
pNewChar ->entityType = ENTITY_MONSTER;
pNewChar ->tableIdx = aniIdx;
for ( i = 0; i < MAX_COUNT_ITEM_PART; i++ ) pNewChar ->stat_itemID [i] = -1;
for ( i = 0; i < MAX_COUNT_SKIN_PART; i++ ) pNewChar ->stat_skinID [i] = -1;
pNewChar ->stat_skinID [SKIN_PART_MONSTER] = GetSkinID ( SKIN_PART_MONSTER, skinIdx );
pNewChar ->attr_skelID = m_pCharLookupMng ->GetBoneIDFromTable ( pNewChar ->entityType, aniIdx );
InitNewChar ( pNewChar );
pNewChar ->ani_curSpeed = 1.0f;
pNewChar ->ani_curRSpeed = 1.0f / pNewChar ->ani_curSpeed;
pNewChar ->ani_option = ANIMOPTION_START_NEW_ANIM;
CheckAuraExist ( 0 );
}
pNewChar ->ani_curSetType = ANIMTYPE_BYCOMMON;
pNewChar ->ani_curItemSetIndex = 0;
pNewChar ->ani_curSetID = 0;
pNewChar ->SetupVectors ();
UpdatePosition ( pNewChar ->ID, pNewChar ->position, pNewChar ->angles );
UpdateSysVBInfo ();
UpdateCharacterState ();
}
#endif | C++ |
#include "../../global_def.h"
#include "../Common.h"
FX_CAuraManager::FX_CAuraManager ()
{
m_auraRenderer = new FX_CAuraRenderer ();
}
FX_CAuraManager::~FX_CAuraManager ()
{
}
int FX_CAuraManager::Update ( float &in_update,
const float in_cur )
{
if ( in_cur < in_update )
return false;
in_update += AURA_UPDATE_TIME;
return true;
}
void FX_CAuraManager::UpdatePos ( AURA_t &in_aura,
const vec3_t in_pttop,
const vec3_t in_ptbottom )
{
if ( in_aura.num_used < MAX_AURA_IN_CHAR )
{
VectorCopy ( in_aura.start [in_aura.num_used].vecPos, in_pttop );
VectorCopy ( in_aura.end [in_aura.num_used].vecPos, in_ptbottom );
in_aura.num_used++;
}
else
{
memmove( &in_aura.start[ 0 ], &in_aura.start[ 1 ], sizeof(DIFFUSETEXVERTEX) * (MAX_AURA_IN_CHAR - 1) );
memmove( &in_aura.end[ 0 ], &in_aura.end[ 1 ], sizeof(DIFFUSETEXVERTEX) * (MAX_AURA_IN_CHAR - 1) );
VectorCopy ( in_aura.start [MAX_AURA_IN_CHAR - 1].vecPos, in_pttop );
VectorCopy ( in_aura.end [MAX_AURA_IN_CHAR - 1].vecPos, in_ptbottom );
}
return;
}
bool FX_CAuraManager::MakePreVertexBuffer ( const AURA_t *in_aura )
{
int startctrl;
int endctrl;
int index, subindex;
int counter;
const float tex_disp = 0.98f / ( (in_aura ->num_used - 1) * (AURA_NUM_DIVIDE + 1) );
float tex_coord_u;
tex_coord_u = 0.99f;
counter = 0;
VectorCopy ( m_PreVB [counter].vecPos, in_aura ->start [0].vecPos );
m_PreVB [counter].d3dColor = D3DCOLOR_WHITE;
m_PreVB [counter].tu = tex_coord_u;
m_PreVB [counter].tv = 0.01f;
counter++;
VectorCopy ( m_PreVB [counter].vecPos, in_aura ->start [0].vecPos );
m_PreVB [counter].d3dColor = D3DCOLOR_WHITE;
m_PreVB [counter].tu = tex_coord_u;
m_PreVB [counter].tv = 0.99f;
counter++;
tex_coord_u -= tex_disp;
int startidx, endidx;
for ( index = 0; \
index < ( in_aura ->num_used - 1 ); \
++index )
{
if ( index == 0 )
startctrl = 0;
else
startctrl = index - 1;
if ( index == in_aura ->num_used - 2 )
endctrl = in_aura ->num_used - 1;
else
endctrl = index + 2;
if ( ( startctrl < 0 ) || ( endctrl < 0 ) || ( startctrl > (in_aura ->num_used - 1) ) || ( endctrl > (in_aura ->num_used - 1) ) )
{
ErrorLog( "index : %d, startstrl : %d, endctrl : %d, AURA_t::num_used : %d", index, startctrl, endctrl, in_aura->num_used );
return false;
}
FX_CatmullRomMulti ( &m_PreVB [counter],
in_aura ->start [index].vecPos , in_aura ->start [startctrl].vecPos,
in_aura ->start [index + 1].vecPos, in_aura ->start [endctrl].vecPos,
AURA_NUM_DIVIDE );
FX_CatmullRomMulti ( &m_PreVB [counter + 1],
in_aura ->end [index].vecPos, in_aura ->end [startctrl].vecPos,
in_aura ->end [index + 1].vecPos, in_aura ->end [endctrl].vecPos,
AURA_NUM_DIVIDE );
startidx = counter + (AURA_NUM_DIVIDE * 2);
endidx = startidx + 1;
VectorCopy ( m_PreVB [startidx].vecPos, in_aura ->start [index + 1].vecPos );
VectorCopy ( m_PreVB [endidx].vecPos, in_aura ->end [index + 1].vecPos );
for ( subindex = 0; \
subindex < ( AURA_NUM_DIVIDE + 1 ); \
++subindex )
{
m_PreVB [counter].d3dColor = D3DCOLOR_WHITE;
m_PreVB [counter].tu = tex_coord_u;
m_PreVB [counter].tv = 0.01f;
counter++;
m_PreVB [counter].d3dColor = D3DCOLOR_WHITE;
m_PreVB [counter].tu = tex_coord_u;
m_PreVB [counter].tv = 0.99f;
counter++;
tex_coord_u -= tex_disp;
}
}
m_numVertexToDraw = counter;
if ( m_numVertexToDraw < 0 )
{
ErrorLog( "m_numVertexToDraw : %d", m_numVertexToDraw );
return false;
}
m_auraRenderer ->LockVB ( m_PreVB, m_numVertexToDraw );
m_auraRenderer ->LockIB ( m_PreIB, m_numIndexToDraw );
return true;
}
void FX_CAuraManager::MakePreIndexBuffer ()
{
int counter = 0;
const int max = (MAX_AURA_IN_CHAR - 1) * (AURA_MAX_DIVIDE + 1) * 2;
for ( WORD index = 0; \
index < max; \
index += 2 )
{
m_PreIB [counter++] = index;
m_PreIB [counter++] = index + 1;
m_PreIB [counter++] = index + 2;
m_PreIB [counter++] = index + 2;
m_PreIB [counter++] = index + 1;
m_PreIB [counter++] = index + 3;
}
m_numIndexToDraw = counter;
return;
}
void FX_CAuraManager::Render ( Fx_CHARACTER_t *in_char,
int *in_numprims,
const int in_shaderIdx,
const int in_numUsed )
{
*in_numprims = (in_numUsed - 1) * (AURA_NUM_DIVIDE + 1) * 2;
m_auraRenderer ->PrepareRender ();
if ( m_pCharShaderMng ->CheckIsEffectShader ( in_shaderIdx ) )
{
m_pCharShaderMng ->PrepareEffectShaderByRef ( in_shaderIdx );
m_auraRenderer ->ShaderRender ( in_char, m_pCharShaderMng ->GetEffectShaderIdx ( in_shaderIdx ), in_numprims );
}
else
{
m_pd3dDevice ->SetTexture ( 0, m_pCharShaderMng ->GetD3DEffectTextureByRef ( in_shaderIdx ) );
m_auraRenderer ->Render ( in_numprims );
}
return;
}
void FX_CAuraManager::SetDevice ( const LPDIRECT3DDEVICE8 device )
{
m_pd3dDevice = device;
m_auraRenderer ->SetDevice ( m_pd3dDevice );
}
void FX_CAuraManager::SetRenderer ( CD3DRender *d3dRender )
{
m_D3DRender = d3dRender;
m_auraRenderer ->SetRenderer ( d3dRender );
return;
}
void FX_CAuraManager::SetShaderMng ( CShaderMng *shaderMng )
{
m_auraRenderer ->SetShaderMng ( shaderMng );
return;
}
bool FX_CAuraManager::PrepareRenderBuffers()
{
m_auraRenderer ->CreateBuffers ();
MakePreIndexBuffer ();
return true;
}
bool FX_CAuraManager::ReleaseRenderBuffers()
{
m_auraRenderer ->ReleaseBuffers ();
return true;
}
void FX_CAuraManager::SetInitialPos ( AURA_t *in_aura,
const vec3_t in_pttop,
const vec3_t in_ptbottom )
{
VectorCopy ( in_aura ->start [0].vecPos, in_pttop );
VectorCopy ( in_aura ->end [0].vecPos, in_ptbottom );
in_aura ->num_used = 1;
return;
}
void FX_CAuraManager::FadeAura ( AURA_t &in_aura )
{
if ( false == in_aura.render )
return;
if ( in_aura.num_used == 0 )
{
in_aura.render = false;
return;
}
memmove( &in_aura.start[ 0 ], &in_aura.start[ 1 ], sizeof(DIFFUSETEXVERTEX) * (in_aura.num_used - 1) );
memmove( &in_aura.end[ 0 ], &in_aura.end[ 1 ], sizeof(DIFFUSETEXVERTEX) * (in_aura.num_used - 1) );
if ( in_aura.num_used > 1 )
in_aura.num_used--;
else
in_aura.render = false;
return;
}
void FX_CAuraManager::Cleanup ()
{
GTH_SAFE_DELETE ( m_auraRenderer );
return;
} | C++ |
#ifndef _CHAR_LOOK_UP_MANAGER_H_JD09JE08H08
#define _CHAR_LOOK_UP_MANAGER_H_JD09JE08H08
class FX_CCharLookupMng
{
public:
FX_CCharLookupMng () {};
~FX_CCharLookupMng() {};
Fx_CHAR_LOOKUP_t m_charLookups[NUM_GEN_LOOKUPS];
#ifdef _GTH_NEW_VERSION
Fx_CHAR_LOOKUP_t m_creatureLookups[NUM_GEN_LOOKUPS];
#endif
Fx_MON_LOOKUP_t m_monLookups [NUM_MON_LOOKUPS];
Fx_ANIM_INFO_t m_aniInfo[MAX_COUNT_ANIM];
int m_fileVersion;
protected:
CFileMng *m_fileMng;
public:
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
void LoadTableInfo ();
void InitTableInfo ();
void SaveTableInfoFromFile( char* filename );
void LoadTableInfoFromFile( char* filename );
void LoadTableInfoFromBuffer( char* filename );
int GetBoneIDFromTable ( const int in_entityType, const int in_entityIdx );
int GetItemAnimIDFromTable ( const int in_entityIdx, const int in_itemIdx, const int in_animIdx );
int GetCommonAnimIDFromTable ( const int in_entityIdx, const int in_animIdx );
int GetSkillAnimIDFromTable ( const int in_entityIdx, const int in_animIdx );
int GetMonAnimIDFromTable ( const int in_entityIdx, const int in_animIdx );
int GetAnimIDFromTable ( const int in_entityType, const int in_entityIdx, const int in_animType,
const int in_itemIdx, const int in_animIdx, const int in_charID,
const int in_isCreature = false );
int GetAnimTypeFromID ( const int in_entityType, const int in_entityIdx, const int in_animType,
const int in_itemIdx, const int in_globalAnimIdx );
int GetIdleAnimation ( const int in_entityType, const int in_entityIdx, const int in_animType, const int in_itemIdx );
#ifdef _GTH_NEW_VERSION
int GetCreatureItemAnimIDFromTable ( const int in_entityIdx, const int in_itemIdx, const int in_animIdx );
int GetCreatureCommonAnimIDFromTable ( const int in_entityIdx, const int in_animIdx );
int GetCreatureSkillAnimIDFromTable ( const int in_entityIdx, const int in_animIdx );
#endif
};
#endif | C++ |
#ifndef _CHARACTER_MANAGER_CLASS_JOIDJ0U309U20
#define _CHARACTER_MANAGER_CLASS_JOIDJ0U309U20
#include "Common.h"
#pragma warning ( disable : 4786 )
#include <list>
#ifdef _FX_CLIENT
struct SHADOWTESTFORMAT
{
D3DXVECTOR4 position;
D3DCOLOR color;
};
#define D3DFVF_SHADOWTEST (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
typedef std::list< Fx_CHARACTER_t * > LIST_CREATURE;
typedef LIST_CREATURE::iterator ITOR_LIST_CREATURE;
extern const int SHADOW_TEX_DIMENSION;
#endif
class FX_CCharManager
{
public:
enum EFFECT_TYPE
{
EFFECT_NORMAL=0,
EFFECT_MISSILE,
EFFECT_BASIC_ATTACK_EFFECT,
};
public:
FX_CCharManager();
~FX_CCharManager();
public:
Fx_CHARACTER_t m_Characters [MAX_CHAR_A_SCENE];
Fx_CHARACTER_t m_CharactersBackup [MAX_CHAR_A_SCENE];
int m_iNumCharacters;
int m_iNumBackupCharacters;
Fx_CHARACTER_t m_creatures [MAX_CREATURE_A_SCENE];
Fx_CHARACTER_t m_creaturesBackup [MAX_CREATURE_A_SCENE];
int m_numCreatures;
int m_numBackupCreatures;
FX_CSkelManager *m_pSkelManager;
FX_CAnimManager *m_pAnimManager;
FX_CSkinManager *m_pSkinManager;
FX_CItemManager *m_pItemManager;
FX_CCharLookupMng *m_pCharLookupMng;
FX_CAuraManager *m_pAuraManager;
FX_CCharShaderMng *m_pCharShaderMng;
FX_CSkinRenderer *m_pSkinRenderer;
CTagManager *m_pTagManager;
CMeshManager *m_pMeshManager;
FX_CBoneManager *m_pBoneManager;
CD3DTextureMng *m_pTexMng;
CFileMng *m_pFileMng;
CScript *m_pScript;
CTimer *m_timer;
CShaderMng *m_shaderMng;
CD3DRender *m_D3DRender;
CMDLMng *m_MDLMng;
FX_CCharUtil *m_pCharUtil;
FX_CMathTbl *m_pMathTbl;
CFrustum *m_frustum;
LPDIRECT3DDEVICE8 m_pd3dDevice;
int m_totalDrawnPrims;
float m_minSquareDist;
float m_currentTime;
float m_elapsedTime;
vec3_t m_tbOriginalCamPos;
float m_tbDuration;
double m_tbStartTime;
float m_tbPreperationDuration;
float m_tbPower;
bool m_tbUse;
bool m_tbDo;
bool m_tbPrepare;
int m_forceUpdateSkin;
#ifdef _FX_CLIENT
LPDIRECT3DTEXTURE8 m_shadowTexture;
LPDIRECT3DSURFACE8 m_shadowSurface;
matrix4x4_t m_shadowView;
matrix4x4_t m_shadowProj;
LPDIRECT3DSURFACE8 m_backBuffer;
LPDIRECT3DSURFACE8 m_zBuffer;
LPDIRECT3DVERTEXBUFFER8 m_shadowVB;
bool m_drawShadows;
CD3DBuffer *m_shadowVBNeo;
vec4_t m_shadowLightVector;
vec4_t m_shadowPlane;
vec4_t m_shadowNormalizedPlane;
matrix4x4_t m_shadowMatrix;
matrix4x4_t m_shadowTranslation;
float m_sqrtTwo;
material_t m_savedMaterial;
LIST_CREATURE m_emptyCreatureList;
LIST_CREATURE m_usedCreatureList;
#endif
#ifdef _FX_TOOL
public:
FX_CMeshTool *m_pMeshTool;
#endif
#ifdef _FXSKELDRAW
public:
FX_CSkelDraw *m_pSkelDraw;
int m_coordBoneIdx;
#endif
public:
bool LoadAllResources();
bool PrepareBuffers();
bool ReleaseBuffers();
bool UpdateCharacterState();
bool UpdateAnimations();
bool RenderItems();
bool RenderAuras();
void PrepareSkinRendering ();
bool RenderSkinsNormal ();
bool RenderEffects ();
void ProcessComboAttack ();
#ifdef _FX_CLIENT
bool RenderSkinsDisappear ();
#endif
void Cleanup();
void UpdatePosition ( const int iCharID, const vec3_t pos, const vec3_t angle );
void StopAnimation ( const int charID, const bool stop );
void SetTexManager ( CD3DTextureMng *texMng );
void SetFileManager ( CFileMng *fileMng );
void SetScript ( CScript *script );
void SetDevice ( LPDIRECT3DDEVICE8 device );
void SetTimer ( CTimer *timer );
void SetShaderMng ( CShaderMng *shaderMng );
void SetRenderer ( CD3DRender *d3dRender );
void SetFrustum ( CFrustum *frustum ) { m_frustum = frustum; }
void SetMDLMng( CMDLMng *MDLMng ) { m_MDLMng = MDLMng; }
void RestoreDeviceObject ();
void GetBoundChar ( Fx_CHARACTER_t *in_char, bboxf_t &out_bound );
void GetBoundCharPreTransform ( Fx_CHARACTER_t *in_char, bboxf_t &out_bound );
void UpdateAura ( Fx_CHARACTER_t *pThisChar, KEYFRAME *pThisFrame, TAG *pThisTag, const bool in_rightHanded );
void PreUpdateAura ( Fx_CHARACTER_t *pThisChar, FX_CSkel *pSkel );
int GetNumDrawnPrimitive () { return m_totalDrawnPrims; };
void StartFrame ();
int GetSkinID ( const int in_type, const int in_internalID );
void SetDefaultCharacter ( const int iCharID );
void SetDefaultSkin ( const int iCharID, const int in_type );
int CheckSkinUpdateTime ( Fx_CHARACTER_t *in_char );
void UpdateSkinUpdateTime ( Fx_CHARACTER_t *in_char );
void SetFPS ( Fx_CHARACTER_t *in_char, const int in_fps );
int GetForceUpdateSkin () { return m_forceUpdateSkin; };
void SetForceUpdateSkin () { m_forceUpdateSkin = true; };
void ReleaseForceUpdateSkin () { m_forceUpdateSkin = false; };
void EndFrame ();
void MakeInterpolator ( Fx_CHARACTER_t *in_char, const float in_duration, const int in_startAnim,
const int in_endAnim, const int in_option );
bool InterpolateAnim ( Fx_CHARACTER_t *in_char );
void FadeAura ( const int in_charID );
void InitAnimation ( const int iCharID, const int aniSetType, const int aniSetIndex, const int aniSetID );
void FixCharacterPosition ();
void InitNewChar ( Fx_CHARACTER_t *in_char );
bool CheckAnimation ( const Fx_CHARACTER_t *in_char, const int in_type, const int in_index, const int in_ID, const int in_groupType );
float GetInitialHeight( Fx_CHARACTER_t *in_char, int in_animIdx );
float GetInitialTall( Fx_CHARACTER_t *in_char, int in_animIdx );
float GetInitialRadius( Fx_CHARACTER_t *in_char, int in_animIdx );
void SetRenderState ();
void CheckAuraExist ( const int in_charIdx );
void UpdateSysVBInfo ();
void EquipItem ( const int iCharID, const itemTable_t *pItem );
bool CharacterCollideCheck ( Fx_CHARACTER_t *in_char );
int SetCharacterSpeed ( Fx_CHARACTER_t *in_char, float in_percent );
#ifdef _FXSKELDRAW
void ClearSkelData ();
void SetSkelDrawData ();
void RenderSkel ();
void SetSkelBBoxData ( const bboxf_t in_bound );
void RenderSkelBBox ();
#endif
private:
void TransformAuraVertices ( const KEYFRAME *pThisFrame, const TAG *pThisTag,
const vec3_t in_vecstart, const vec3_t in_vecend,
const matrix4x4_t *in_matTransform,
vec3_t out_vecstart, vec3_t out_vecend );
void SetSkinUpdateTime ( Fx_CHARACTER_t *in_char, const float in_time );
int GetFPS ( Fx_CHARACTER_t *in_char );
float GetSPF ( Fx_CHARACTER_t *in_char );
void PrepareNewAura ( Fx_CHARACTER_t *in_char );
public:
#ifdef _FX_CLIENT
public:
void AddEffect ( int type, int in_effectID, Fx_CHARACTER_t *in_char , float in_zpos );
void ChangeAnimation ( const int iCharID, const int aniSetType, const int aniSetIndex, const int aniSetID, const float *in_animSpeed,
const bool in_forceChage );
void EquipAllItem ( const int iCharID );
void SetInitialDataForNewChar ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void SetInitialDataForExistChar ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void SetPCSpecificDataNormal ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void SetPCSpecificDataTransform ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void SetNonPCSpecificData ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void CheckNewAddedEffect ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void GenerateCharacter ( syncCharacter_t *data, int numData );
void GenerateCharacterAffect ( Fx_CHARACTER_t *pNewChar, int affectNum, int affectIdx[] );
void GenerateMyCharacter ();
void GenerateOtherCharacter ( int iCharID );
float GetAnimFraction ( Fx_CHARACTER_t *in_char );
float GetCharPanelScreenPos ( Fx_CHARACTER_t *in_char, vec3_t out_pos );
Fx_CHARACTER_t* SearchCursorEntityNeo2 ( const vec3_t in_camPos, const vec3_t in_camAngle,
matrix4x4_t *in_camTransMat, const float in_minSquareDist,
const vec2_t in_mousePos, const vec2_t in_viewportSize );
void SetAnimationSpeedInSec ( Fx_CHARACTER_t *in_char, const float in_second, int isNext );
void SetTargetID ();
void SetTrembling ( const vec3_t in_position, const float in_preperation, const float in_duration, const float in_power );
void StopTrembling ();
void CheckTrembling ();
void SetCharTrembling ( const int in_charIdx, const float in_duration, const float in_power );
void StopCharTrembling ( const int in_charIdx );
void CheckCharTrembling ();
void RenderShadow ();
void MakeShadow ( Fx_CHARACTER_t *in_char );
#endif
#ifdef _FX_TOOL
public:
int CheckCorrectBone ( Fx_CHARACTER_t *pThisChar );
void GenerateAniToolsCharacter ( int entityType, int skinIdx, int aniIdx );
Fx_CHARACTER_t* SearchCursorEntity ( const vec3_t pos, const vec3_t in_camangle,
matrix4x4_t *transMat, const float minSquareDist,
const vec2_t mouse, const vec2_t viewport );
#endif
public:
int StartNewComboAttack ( Fx_CHARACTER_t *in_char );
int SetNextBeginFrame ( Fx_CHARACTER_t *in_char );
int SetNextDamageFrame ( Fx_CHARACTER_t *in_char );
int SetNextFreeFrame ( Fx_CHARACTER_t *in_char );
int GotDamageMessage ( int in_defenderIdx, int in_defenderType, int in_attackerIdx, int in_attackerType, int in_damage, int in_stun );
int FindDamageBufferEntry ( Fx_CHARACTER_t *in_char, bool in_used );
int DeleteDamageBufferEntry ( Fx_CHARACTER_t *in_char, int in_index );
int ProcessDamageFrame ( Fx_CHARACTER_t *in_char );
void ClearDamageBuffer ( Fx_CHARACTER_t *in_char );
int SetNextStartFrame ( Fx_CHARACTER_t *in_char );
void ShowAttackEffect ( Fx_CHARACTER_t *in_attacker, int damage = 0 );
Fx_CHARACTER_t* FindCharacterByServerIndex ( int in_serverIdx, int in_type );
int ShowDamage ( Fx_CHARACTER_t *in_char, int in_entryIdx );
float CalcAttackLength ( Fx_CHARACTER_t *in_char );
int SetCharacterColorChanging ( Fx_CHARACTER_t *in_char, vec3_t in_startColor, vec3_t in_endColor, float in_applyTime );
void ApplyCharacterColorChanging ( Fx_CHARACTER_t *in_char );
void RestoreCharacterColorChanging ( Fx_CHARACTER_t *in_char );
void SetCharacterColorChangingDefined ( Fx_CHARACTER_t *in_char, int in_color, float in_applyTime );
void MakeEmptyCreatureList ();
Fx_CHARACTER_t* GetEmptyCreature ();
void SetEmptyCreature ( Fx_CHARACTER_t *in_creature );
bool UpdateAnimationsCreature ();
int CheckSkinUpdateTimeCreature ( Fx_CHARACTER_t *in_creature );
void FixCreaturePosition ();
void GenerateCharacterCreature ();
void CheckNewCreature ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void CheckExistCreature ( Fx_CHARACTER_t *in_char, syncCharacter_t *in_data );
void ProcessComboAttack ( Fx_CHARACTER_t *in_char );
inline void CalcComboAttackTime ( Fx_CHARACTER_t *in_char );
inline float CalcFreeComboAttackTime ( Fx_CHARACTER_t *in_char );
bool GetPositionForTeleport ( int in_targetIndex, int in_targetType, vec3_t out_position );
Fx_CHARACTER_t * GetCharacter(int Index)
{
if(Index < 0 || Index >= MAX_CHAR_A_SCENE) return NULL;
return &m_Characters[Index];
}
};
#ifdef _FX_CLIENT
inline bool FX_CCharManager::CheckAnimation ( const Fx_CHARACTER_t *in_char,
const int in_type,
const int in_index,
const int in_ID,
const int in_groupType )
{
int aniInfoIdx = m_pCharLookupMng ->GetAnimIDFromTable ( in_char ->entityType, in_char ->tableIdx, in_type, in_index, in_ID, in_char->ID );
if( aniInfoIdx < 0 || aniInfoIdx >= MAX_COUNT_ANIM )
return false;
if ( m_pCharLookupMng ->m_aniInfo [aniInfoIdx].groupID == in_groupType )
return true;
return false;
}
#endif
#endif
| C++ |
#ifndef _COMMON_H_JF02J3PPW02990U3042
#define _COMMON_H_JF02J3PPW02990U3042
#include <windows.h>
#include <basetsd.h>
#include <math.h>
#include <stdio.h>
#include <D3DX8.h>
#include <DXErr8.h>
#include <tchar.h>
#include "../common/D3DApp.h"
#include "../common/D3DUtil.h"
#include "../common/DXUtil.h"
#include "../resource.h"
#include "ObjectDefs.h"
#include "FX_Etcs/RenderRelated.h"
#define MAX_CHAR_A_SCENE 50
#define MAX_CREATURE_A_SCENE 50
#define MAX_COUNT_BONE_IN_CHAR 50
#define MAX_COUNT_SKEL 200
#define MAX_COUNT_ANIM_VER100 200
#define MAX_COUNT_ANIM_VER110 500
#define FILESIZE_LOOKUP_VER100 140000
#define FILESIZE_LOOKUP_VER110 150000
#define MAX_COUNT_ANIM 2000
#define MAX_COUNT_SKIN_MESH 800
#define MAX_COUNT_ITEM_MESH 500
#define MAX_COUNT_TEXTURE 1000
#define MAX_COUNT_CHAR_PER_ITEM 100
#define MAX_COUNT_AVAIL_ITEM 200
#define MAX_COUNT_BONE 150
#define MAX_COUNT_EFFECT_TEXTURE 50
#define RESOURCE_VERSION_VALUE 101
#define RESOURCE_VERSION_TEXT "101"
#define FILE_BASE _T("./")
#define FILENAME_BASE _T("listdata/")
#define FILENAME_SKEL_LIST FILENAME_BASE _T("SkelList.fxd")
#define FILENAME_ANIM_LIST FILENAME_BASE _T("AnimList.fxd")
#define FILENAME_ITEM_LIST FILENAME_BASE _T("ItemList.fxd")
#define FILENAME_SKIN_LIST FILENAME_BASE _T("SkinList.fxd")
#define FILENAME_TEX_LIST FILENAME_BASE _T("TexList.fxd")
#define FILENAME_AURA_LIST FILENAME_BASE _T("AuraList.fxd")
#define FILENAME_SKINITEM_LIST FILENAME_BASE _T("ItemForSkin.fxd")
#define FILENAME_OBJCLASS_LIST FILENAME_BASE _T("ObjClassList.fxd")
#define FILENAME_EFFECT_TEX_LIST FILENAME_BASE _T("effect_texture.fxd")
#define FILENAME_SKIN_HAIR FILENAME_BASE _T("SkinHairList.fxd")
#define FILENAME_SKIN_HEAD FILENAME_BASE _T("SkinHeadList.fxd")
#define FILENAME_SKIN_UPPER FILENAME_BASE _T("SkinUpperList.fxd")
#define FILENAME_SKIN_LOWER FILENAME_BASE _T("SkinLowerList.fxd")
#define FILENAME_SKIN_HAND FILENAME_BASE _T("SkinHandList.fxd")
#define FILENAME_SKIN_LEG FILENAME_BASE _T("SkinLegList.fxd")
#define FILENAME_SKIN_FOOT FILENAME_BASE _T("SkinFootList.fxd")
#define FILENAME_SKIN_MONSTER FILENAME_BASE _T("SkinMonsterList.fxd")
#define INTERNAL_INFO _T("internal_infos/")
#define FILENAME_TAGLIST INTERNAL_INFO _T("TagListExt_") RESOURCE_VERSION_TEXT _T(".dat")
#define FILENAME_MESHLIST INTERNAL_INFO _T("MeshListExt.dat")
#define FILENAME_BONELIST INTERNAL_INFO _T("BoneListExt.dat")
#define FILENAME_CHARTABLE INTERNAL_INFO _T("CharLookupTable.bdt")
#define FILENAME_SIN_TABLE INTERNAL_INFO _T("fsintbl.bdt")
#define FILENAME_COS_TABLE INTERNAL_INFO _T("fcostbl.bdt")
#define FILENAME_ATTACKMOTION_INFO INTERNAL_INFO _T("AttackMotionInfo.dat")
#define FILENAME_SKINDFT_LIST _T("defaultchar.cfg")
#define FX_ANIM_ERROR 0.0001f
#define VERTEX_BUFFER_SIZE 7000
#define INDEX_BUFFER_SIZE 21000
#define MAX_NUM_STATIC_EFFECT 10
#define SIZE_PREVB_AURA 3000
#define SIZE_PREIB_AURA 6000
#ifdef _FXSKELDRAW
# define SIZE_VB_SKEL_RENDER 400
# define SIZE_IB_SKEL_RENDER 36
#endif
#define GTH_CHAR_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_NORMAL | GTH_FORMAT_TEXVERTEX( 1 ) )
#define GTH_AURA_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_DIFFUSE | GTH_FORMAT_TEXVERTEX( 1 ) )
#ifdef _FXSKELDRAW
# define GTH_SKEL_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_NORMAL )
#endif
#define FX_DEFAULT_SKIN_PART_NUMBER 4
#define FX_MAX_EQUIPMENT_NUMBER 7
#define NUM_GEN_LOOKUPS 8
#define NUM_MON_LOOKUPS 200
#define SIZE_BONENAME 32
#define MAX_CHILDBONE 8
#define MAX_ROOTBONE_ID 8
#define MAX_TAG 35
#define MAX_AURA_IN_CHAR 6
#define AURA_MAX_DIVIDE 10
#define AURA_NUM_DIVIDE 4
#define AURA_UPDATE_TIME 0.05f
#define ANIM_FRAME_ERROR_VALUE 9999999.9f
#define COMBO_DAMAGE_REQUEST_FRAME_OFFSET 5
const float INTERPOLATE_FRACTION = 0.4f;
enum
{
MON_ALIVE_STATE_SPAWN = 0,
MON_ALIVE_STATE_NORMAL,
MON_ALIVE_STATE_CORPSE,
MON_ALIVE_STATE_DISAPPEAR,
MON_ALIVE_STATE_DIE,
MON_ALIVE_STATE_FADE,
};
enum
{
CHAR_ATTACK_PREPARE = 0,
CHAR_ATTACK_ENABLE,
CHAR_ATTACK_DISABLE,
CHAR_ATTACK_FORCEDWORD = 0x7fffffff
};
#define CHAR_ATTACK_SUCCEED true
#define CHAR_ATTACK_FAILED false
enum
{
CHAR_SOUND_ENABLE,
CHAR_SOUND_DISABLE,
CHAR_SOUND_FORCEDWORD = 0x7fffffff
};
enum
{
CHAR_SHADER_AURA_1 = 0,
CHAR_SHADER_AURA_2,
CHAR_SHADER_AURA_3,
CHAR_SHADER_AURA_4,
CHAR_SHADER_CHAR_SELECT_NORMAL,
CHAR_SHADER_CHAR_SELECT_HOSTILE,
CHAR_SHADER_CHAR_SELECT_3,
CHAR_SHADER_CHAR_SELECT_4,
CHAR_SHADER_ITEM_SELECT_1,
CHAR_SHADER_ITEM_SELECT_2,
CHAR_SHADER_ITEM_SELECT_3,
CHAR_SHADER_ITEM_SELECT_4,
CHAR_SHADER_MONSTER_DEAD_1,
CHAR_SHADER_FORCEDWORD = 0x7fffffff
};
enum
{
INTERPOLATE_NORMAL = 0,
INTERPOLATE_USE_CURFRAME,
INTERPOLATE_USE_EOA,
INTERPOLATE_FORCEDWORD = 0x7fffffff
};
enum
{
ANIMOPTION_NORMAL = 0,
ANIMOPTION_START_NEW_ANIM,
ANIMOPTION_COMBO_ATTACK,
ANIMOPTION_START_ATTACK,
ANIMOPTION_ACCELERATE_ANIM,
ANIMOPTION_FORCEDWORD = 0x7fffffff
};
enum
{ ANIMCHECK_NORMAL,
ANIMCHECK_EOP,
ANIMCHECK_EOA,
ANIMCHECK_RESULT_NORMAL,
ANIMCHECK_RESULT_END,
ANIMCHECK_RESULT_EOP,
ANIMCHECK_RESULT_EOA,
ANIMCHECK_FORCEDWORD = 0x7fffffff
};
enum
{
SKIN_PART_HAIR,
SKIN_PART_HEAD,
SKIN_PART_UPPER,
SKIN_PART_LOWER,
SKIN_PART_HAND,
SKIN_PART_LEG,
SKIN_PART_FOOT,
SKIN_PART_MONSTER,
MAX_COUNT_SKIN_PART,
SKIN_PART_FORCEDWORD = 0x7fffffff
};
enum
{
ITEM_PART_OVERHEAD_FAR,
ITEM_PART_OVERHEAD_NEAR,
ITEM_PART_ARM_R,
ITEM_PART_ARM_L,
ITEM_PART_NECK,
ITEM_PART_BODY,
ITEM_PART_HAND_R,
ITEM_PART_HAND_L,
ITEM_PART_BACKHAND_R,
ITEM_PART_BACKHAND_L,
ITEM_PART_KNEE_R,
ITEM_PART_KNEE_L,
ITEM_PART_MIDDLEAIR_R,
ITEM_PART_MIDDLEAIR_L,
ITEM_PART_WAIST,
ITEM_PART_SHOULDER,
ITEM_PART_BACK,
ITEM_PART_WAIST_R,
ITEM_PART_WAIST_L,
ITEM_PART_ELBOW_R,
ITEM_PART_ELBOW_L,
ITEM_PART_HAIR,
ITEM_PART_HEAD,
ITEM_PART_FACE,
ITEM_PART_TRANS,
ITEM_PART_GROUNDAIR_R,
ITEM_PART_GROUNDAIR_L,
ITEM_PART_GROUND,
ITEM_PART_RESERVED,
ITEM_PART_CREATURE_TYPE_0,
ITEM_PART_CREATURE_TYPE_1,
ITEM_PART_CREATURE_TYPE_2,
ITEM_PART_CREATURE_TYPE_3,
ITEM_PART_CREATURE_TYPE_4,
MAX_COUNT_ITEM_PART,
ITEM_PART_FORCEDWORD = 0x7fffffff
};
typedef enum
{
FX_ANIM_GROUP_NULL = -1,
FX_ANIM_GROUP_MOVE = 0,
FX_ANIM_GROUP_BASIC,
FX_ANIM_GROUP_ATTACK,
FX_ANIM_GROUP_DEFENSE,
FX_ANIM_GROUP_MAGIC,
FX_ANIM_GROUP_SOCIAL,
FX_ANIM_GROUP_FORCEDWORD = 0x7fffffff
} Fx_ANIM_GROUP_t, *Fx_ANIM_GROUP_pt;
typedef union
{
struct
{
unsigned changable :1;
unsigned repeatable :1;
unsigned movable :1;
unsigned alive :1;
} type;
DWORD value;
} Fx_ANIM_STATE_t, *Fx_ANIM_STATE_pt;
typedef struct
{
int groupID;
Fx_ANIM_STATE_t state;
} Fx_ANIM_INFO_t, *Fx_ANIM_INFO_pt;
struct Fx_CHARACTER_t;
typedef struct
{
int meshID;
int count;
Fx_CHARACTER_t *characterPtr[ MAX_COUNT_CHAR_PER_ITEM ];
int tagID[ MAX_COUNT_CHAR_PER_ITEM ];
int parentTagID[ MAX_COUNT_CHAR_PER_ITEM ];
} CHAR_BUFFER_t;
enum
{
GEN_TYPE_SPIRIT = 0,
GEN_TYPE_WIND,
GEN_TYPE_WATER,
GEN_TYPE_SOIL,
GEN_TYPE_POISON,
GEN_TYPE_IRON,
GEN_TYPE_FIRE,
GEN_TYPE_BODY,
NUM_GEN_TYPE,
};
class FX_CCharManager;
class FX_CSkinManager;
class FX_CSkelManager;
class FX_CAnimManager;
class FX_CItemManager;
class FX_CAuraManager;
class FX_CCharLookupMng;
class FX_CCharShaderMng;
class FX_CItemRenderer;
class FX_CSkinRenderer;
class FX_CAuraRenderer;
class FX_CAnim;
class FX_CMesh;
class FX_CSkel;
class CTagManager;
class CMeshManager;
class CBoneManager;
typedef enum
{
SKIN_HAIR = 0x00,
SKIN_HEAD,
SKIN_UPPER,
SKIN_LOWER,
SKIN_HAND,
SKIN_LEG,
SKIN_FOOT,
SKIN_MONSTER,
ITEM_OVERHEAD = 0x10,
ITEM_ARMOR,
ITEM_AIR,
ITEM_WEAPON,
TYPE_DONTCARE = -1,
FORCEDWORD = 0x7fffffff
} MESHTYPE_t, *MESHTYPE_pt;
typedef struct
{
union
{
struct
{
unsigned spirit :1;
unsigned wind :1;
unsigned water :1;
unsigned soil :1;
unsigned poison :1;
unsigned iron :1;
unsigned fire :1;
unsigned body :1;
unsigned :0;
} bit;
unsigned int value;
} gen;
MESHTYPE_t type;
} MESHINFO_t, *MESHINFO_pt;
typedef struct
{
char desc [256];
MESHINFO_t meshinfo;
} MESH_FILEINFO;
typedef struct
{
int sub [4];
} FX_BONESTRUCT_ID;
typedef struct
{
int vertexCount;
int ibStart;
int ibNumber;
int vbStart;
int vbNumber;
} FX_BUFFERINDEX_t;
enum
{
ANIM_ITEM_IDLE = 0,
ANIM_ITEM_WALK,
ANIM_ITEM_WALK_BACK,
ANIM_ITEM_WALK_LEFT,
ANIM_ITEM_WALK_RIGHT,
ANIM_ITEM_RUN,
ANIM_ITEM_PRE_ATTACK,
ANIM_ITEM_ATTACK_0,
ANIM_ITEM_ATTACK_1,
ANIM_ITEM_ATTACK_2,
ANIM_ITEM_ATTACK_3,
ANIM_ITEM_ATTACK_4,
ANIM_ITEM_DEFENSE,
ANIM_ITEM_AVOID,
ANIM_ITEM_RECOVERY,
ANIM_ITEM_ATTACKED_0,
ANIM_ITEM_ATTACKED_1,
ANIM_ITEM_DEAD_0,
ANIM_ITEM_DEAD_1,
ANIM_ITEM_DYING_0,
ANIM_ITEM_DYING_1,
ANIM_ITEM_FLY,
ANIM_ITEM_SIT,
ANIM_ITEM_STAND,
ANIM_ITEM_LIE,
ANIM_ITEM_EVENT,
ANIM_ITEM_SOCIAL,
ANIM_ITEM_JUMP,
ANIM_ITEM_SIT_IDLE,
ANIM_ITEM_SKILLCASTING,
ANIM_ITEM_CASTINGIDLE,
ANIM_ITEM_SOCIAL_BOW,
ANIM_ITEM_SOCIAL_SHOUT,
MAX_ANIMCOUNT_TYPE = 50,
};
enum
{
ANIM_COMMON_COMMON_0 = 0,
ANIM_COMMON_COMMON_1,
ANIM_COMMON_COMMON_2,
ANIM_COMMON_COMMON_3,
ANIM_COMMON_COMMON_4,
ANIM_COMMON_COMMON_5,
ANIM_COMMON_COMMON_6,
ANIM_COMMON_COMMON_7,
ANIM_COMMON_COMMON_8,
ANIM_COMMON_COMMON_9,
MAX_ANIMCOUNT_COMMON = 100
};
enum
{
ANIM_SKILL_SKILL_0 = 0,
ANIM_SKILL_SKILL_1,
ANIM_SKILL_SKILL_2,
ANIM_SKILL_SKILL_3,
ANIM_SKILL_SKILL_4,
ANIM_SKILL_SKILL_5,
ANIM_SKILL_SKILL_6,
ANIM_SKILL_SKILL_7,
ANIM_SKILL_SKILL_8,
ANIM_SKILL_SKILL_9,
MAX_ANIMCOUNT_SKILL = 200,
};
typedef struct
{
int anim_type [MAX_ANIMCOUNT_TYPE];
char desc[256];
} ANIM_t;
#define MAX_ANIMCOUNT_ITEM 10
typedef struct
{
ANIM_t anim_item [MAX_ANIMCOUNT_ITEM];
int anim_common [MAX_ANIMCOUNT_COMMON];
char commonDesc[256];
int anim_skill [MAX_ANIMCOUNT_SKILL];
char skillDesc[256];
} ANIMSET_t;
typedef enum
{
ANIMTYPE_BYITEM = 0,
ANIMTYPE_BYCOMMON,
ANIMTYPE_BYSKILL,
} Fx_CHAR_ANIMTYPE_t;
typedef struct
{
int boneIdx;
ANIMSET_t animset;
} Fx_CHAR_LOOKUP_t;
typedef struct
{
int boneIdx;
int anim_monster [MAX_ANIMCOUNT_TYPE];
char desc[256];
} Fx_MON_LOOKUP_t;
typedef struct
{
float frame;
vec3_t vecOffset;
vec4_t quatRotate;
vec4_t quatCoordinate;
} KEYFRAME;
typedef struct
{
INT iBoneID;
INT iNumKeyframe;
FLOAT fTimePerKeyframe;
KEYFRAME* pKeyframe;
} TRACK;
typedef union
{
struct
{
unsigned subtrack :1;
unsigned :0;
} bit;
unsigned int value;
} ANIM_PROPERTY_t;
typedef struct
{
vec4_t xformed_start;
vec4_t xformed_end;
DIFFUSETEXVERTEX start [MAX_AURA_IN_CHAR];
int num_used;
float height;
DIFFUSETEXVERTEX end [MAX_AURA_IN_CHAR];
int shaderIdx;
float nextUpdate;
float correction;
bool made;
bool render;
} AURA_t;
typedef struct
{
bool used;
WORD defenderIdx;
WORD defenderType;
WORD attackerIdx;
WORD attackerType;
WORD attackType;
WORD damage;
DWORD identifier;
bool stun;
bool expired;
} ATTACKINFO_t;
#define MAX_COUNT_ATTACK_INFOS 10
enum
{
CHAR_COLOR_RED = 0,
CHAR_COLOR_GREEN,
CHAR_COLOR_BLUE,
CHAR_COLOR_YELLOW,
CHAR_COLOR_CYAN,
CHAR_COLOR_MAGENTA,
CHAR_COLOR_MAX
};
struct Fx_CHARACTER_t
{
entityType_t entityType;
int tableIdx;
int pcJob;
int targetIdx;
int targetID;
vec3_t position;
int targetType;
vec3_t angles;
int ID;
int useInterpolation;
i3characterEvent_t oldEvent;
int skinPart [FX_DEFAULT_SKIN_PART_NUMBER];
#ifdef _FX_CLIENT
int idxOnServer;
int equipNumber;
char name [64];
//lucky 2012 new GM system
int gameMaster;
//end
char boothName[64];
int boothState;
int equipment [FX_MAX_EQUIPMENT_NUMBER];
i3characterEvent_t event;
int worldIdx;
float mouseAngle;
vec3_t mousePos;
int isAlive;
vec3_t syncPosition;
float moveSpeed;
int curRA;
int curSA;
int calMaxRA;
int calMaxSA;
float summonValidTime;
int isTransform;
int transformEntityIdx;
int transformType;
chatMessage chatMsg;
float chatMsgTime;
int scriptFlag;
int isNewChar;
int chaosPoint;
int pvpMode;
int generalSpeed;
bool bHide;
#endif
vec3_t mins;
vec3_t maxs;
vec3_t forward;
vec3_t right;
vec3_t up;
float stat_height;
float stat_disp_x;
float stat_disp_y;
float stat_fakeHeight;
matrix4x4_t stat_matTransform;
float stat_scale;
int stat_sound;
int stat_recoveryTime;
float stat_attackSpeed;
float stat_radius;
Fx_CHARACTER_t *stat_collidedChar;
int stat_alive;
int stat_itemID [MAX_COUNT_ITEM_PART];
int stat_skinID [MAX_COUNT_SKIN_PART];
int stat_moveID [MAX_COUNT_ITEM_PART];
BYTE stat_attacker;
BYTE stat_LODLevel;
float stat_attackTime;
int attr_skelID;
float attr_tall;
int ani_option;
int ani_curSetType;
int ani_curItemSetIndex;
int ani_curSetID;
int ani_nextSetType;
int ani_nextItemSetIndex;
int ani_nextSetID;
float ani_curSpeed;
float ani_curRSpeed;
float ani_nextSpeed;
float ani_nextRSpeed;
int ani_curIdx;
Fx_ANIM_STATE_t ani_curState;
int ani_curGroup;
int ani_nextIdx;
Fx_ANIM_STATE_t ani_nextState;
int ani_nextGroup;
float ani_elapsed;
float ani_fraction;
float ani_oldFrame;
int ip_option;
float ip_totalTime;
float ip_curTime;
FX_CAnim *ip_startAnim;
FX_CAnim *ip_endAnim;
KEYFRAME key_curFrames [MAX_COUNT_BONE_IN_CHAR];
KEYFRAME key_resultFrames[MAX_COUNT_BONE_IN_CHAR];
KEYFRAME key_copiedFrames[MAX_COUNT_BONE_IN_CHAR];
int key_curIndex [MAX_COUNT_BONE_IN_CHAR];
int key_nextIndex [MAX_COUNT_BONE_IN_CHAR];
float key_displace [MAX_COUNT_BONE_IN_CHAR];
int ren_updateFPS;
float ren_updateSPF;
FX_BUFFERINDEX_t ren_vtxBufferIdx[MAX_COUNT_SKIN_PART];
float ren_nextTime;
AURA_t ren_auraLHandData;
AURA_t ren_auraRHandData;
matrix4x4_t ren_tagMatrixData [MAX_COUNT_ITEM_PART];
vec3_t ren_xformedPelvisPos;
float ren_squareDist;
Fx_CHARACTER_t *ren_closerChar;
Fx_CHARACTER_t *ren_fartherChar;
double ren_stampedAppTime;
int ren_staticEffectIndex [MAX_NUM_STATIC_EFFECT];
int ren_staticEffectLevel [MAX_NUM_STATIC_EFFECT];
int ren_staticEffectEntityIndex [MAX_NUM_STATIC_EFFECT];
float ren_generalSpeed;
float ren_oldGeneralSpeed;
int ren_numStaticEffects;
int ren_renderThisFrame;
bool flag_tagMatrixMade [MAX_COUNT_ITEM_PART];
bool flag_interpolation;
bool flag_culled;
bool flag_useLHandAura;
bool flag_useRHandAura;
bool flag_disappear;
bool flag_appTimeStamped;
int flag_replayAnim;
bool flag_disappearSound;
bool flag_forceUpdate;
bool flag_drawSpawnEffect;
int attackComboType;
bool flag_outOfMySight;
#ifdef _FX_TOOL
bool flag_renderCharAura;
bool flag_renderSkelBound;
#endif
int soundTime;
ATTACKINFO_t atk_infoBuffer [MAX_COUNT_ATTACK_INFOS];
int atk_curCombo;
int atk_nextStartFrame;
int atk_indexStart;
int atk_nextBeginFrame;
int atk_indexBegin;
int atk_nextDamageFrame;
int atk_indexDamage;
int atk_nextFreeFrame;
int atk_indexFree;
int atk_changeEvent;
int atk_resend;
int atk_playAnim;
float atk_freeAttackTime;
float atk_originalAttackTime;
int atk_sendRangeAttackResend;
int atk_processDamage;
vec3_t tb_originalPos;
float tb_duration;
double tb_startTime;
float tb_power;
bool tb_do;
int cc_inUse;
vec3_t cc_lightColorStart;
vec3_t cc_lightColorEnd;
float cc_timeElapsed;
int isCreature;
int cr_inUse;
int cr_creatureIndex;
Fx_CHARACTER_t *cr_creature;
Fx_CHARACTER_t *cr_owner;
Fx_CHARACTER_t()
{
}
BOOL m_bWaitingRoom;
int m_JoinNum;
int m_NameColorIdx;
BOOL m_bObserveMode;
#ifndef _FX_TOOL
void GetFwdVector ( vec3_t vec )
{
VectorSet ( vec, forward [0], forward [1], forward [2] );
}
void GetRightVector ( vec3_t vec )
{
VectorSet ( vec, right [0], right [1], right [2] );
}
void GetUpVector ( vec3_t vec )
{
VectorSet ( vec, up [0], up [1], up [2] );
}
#endif
void SetupVectors () { AngleVectors ( angles, forward, right, up ); }
};
typedef struct
{
char name [256];
} Fx_TEX_BUF_t;
typedef struct
{
char name [256];
UINT id;
} Fx_ANIM_BUF_t, Fx_SKEL_BUF_t;
typedef struct
{
char name [256];
UINT id;
char texname [256];
} Fx_ITEM_BUF_t, Fx_SKIN_BUF_t;
typedef struct
{
char name[ 68 ];
int shader;
int surfaceFlags;
int isShader;
} CHAR_SHADERREF_t;
#include "FX_Etcs/Utilities.h"
#include "FX_Base/Animation.h"
#include "FX_Base/Skeleton.h"
#include "FX_Base/Mesh.h"
#include "FX_Managers/TagManager.h"
#include "FX_Renderer/ItemRenderer.h"
#include "FX_Renderer/SkinRenderer.h"
#include "FX_Renderer/AuraRenderer.h"
#ifdef _FXSKELDRAW
# include "FX_Managers/SkelDrawManager.h"
#endif
#ifdef _OBJECTMNG
# include "FX_Managers/ObjectManager.h"
# include "FX_Managers/ObjectClassManager.h"
#endif
#include "FX_Managers/AuraMAnager.h"
#include "CharacterManager.h"
#include "FX_Managers/AnimationManager.h"
#include "FX_Managers/ItemManager.h"
#include "FX_Managers/SkeletonManager.h"
#include "FX_Managers/SkinManager.h"
#include "FX_Managers/CharLookupManager.h"
#include "FX_Managers/CharShaderManager.h"
extern const vec4_t UNIT_X_QUAT;
extern const matrix4x4_t IDENTITY_MATRIX;
extern const vec3_t ZERO_VECTOR3;
extern vec4_t GLOBAL_QUAT_1;
extern vec4_t GLOBAL_QUAT_2;
extern vec4_t GLOBAL_QUAT_3;
extern vec3_t GLOBAL_DXVEC3_1;
extern vec3_t GLOBAL_DXVEC3_2;
extern vec3_t GLOBAL_DXVEC3_3;
extern vec3_t GLOBAL_DXVEC3_4;
extern vec3_t GLOBAL_DXVEC3_5;
extern vec3_t GLOBAL_DXVEC3_6;
extern vec3_t GLOBAL_DXVEC3_7;
extern vec3_t GLOBAL_DXVEC3_8;
extern vec3_t GLOBAL_DXVEC3_9;
extern vec3_t GLOBAL_DXVEC3_10;
extern vec3_t GLOBAL_DXVEC3_11;
extern vec4_t GLOBAL_DXVEC4_1;
extern vec4_t GLOBAL_DXVEC4_2;
extern vec4_t GLOBAL_DXVEC4_3;
extern matrix4x4_t GLOBAL_DXMATRIX_1;
extern vec3_t GLOBAL_VEC3_1;
extern vec3_t GLOBAL_VEC3_2;
extern vec3_t GLOBAL_VEC3_3;
extern vec3_t GLOBAL_VEC3_4;
extern vec4_t GLOBAL_VEC4_1;
extern vec4_t GLOBAL_VEC4_2;
extern vec4_t GLOBAL_VEC4_3;
extern vec4_t GLOBAL_VEC4_4;
extern vec4_t GLOBAL_VEC4_5;
extern matrix4x4_t GLOBAL_MATRIX_1;
extern matrix4x4_t GLOBAL_MATRIX_2;
extern matrix4x4_t GLOBAL_SCALEMATRIX;
extern const float FX_DEGTORAD;
extern bboxf_t GLOBAL_BBOX;
#ifdef _FXDEBUG
extern char DBGSTRING [MAX_PATH];
#endif
#ifdef _FX_TOOL
#pragma warning ( disable : 4786 )
#include <vector>
#define VEC_STRING std::vector<std::string>
typedef char FILENAME [256];
#include "FX_Tools/Tool.h"
#endif
#endif
| C++ |
#include "../../global_def.h"
#include "../Common.h"
FX_CAuraRenderer::FX_CAuraRenderer ()
{
m_VB = NULL;
m_IB = NULL;
Initialize();
if ( g_resCounter->Enabled() )
{
g_resCounter->Add_DataType( RESCOUNTER_CHAR_AURARENDERER, sizeof(FX_CAuraRenderer) );
}
}
bool FX_CAuraRenderer::Initialize ()
{
return true;
}
bool FX_CAuraRenderer::CreateBuffers ()
{
m_VB = new CD3DBuffer ();
m_IB = new CD3DBuffer ();
int indicesize = (AURA_MAX_DIVIDE + 1) * (MAX_AURA_IN_CHAR - 1) * 6;
m_VB ->Create ( VERTEX_BUFFER_SIZE,
GTH_FORMAT_XYZ | GTH_FORMAT_DIFFUSE | GTH_FORMAT_TEXVERTEX(1),
GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER );
m_IB ->Create ( indicesize,
GTH_FORMAT_INDEX16,
GTH_INDEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
return true;
}
void FX_CAuraRenderer::ReleaseBuffers ()
{
if ( m_VB ) m_VB ->Release ();
if ( m_IB ) m_IB ->Release ();
GTH_SAFE_DELETE ( m_VB );
GTH_SAFE_DELETE ( m_IB );
return;
}
void FX_CAuraRenderer::Cleanup()
{
ReleaseBuffers();
return;
}
bool FX_CAuraRenderer::PrepareRender ()
{
m_D3DRender ->SetVertexShader ( GTH_AURA_FORMAT );
m_D3DRender ->SetStreamSource ( 0, m_VB ->GetD3DVertexBuffer(), sizeof (DIFFUSETEXVERTEX) );
m_D3DRender ->SetIndices ( m_IB ->GetD3DIndexBuffer (), 0L );
m_D3DRender ->SetTransform ( D3DTS_WORLD, (matrix4x4_t *)&IDENTITY_MATRIX );
return true;
}
void FX_CAuraRenderer::LockVB ( DIFFUSETEXVERTEX *in_preVB,
const int in_vertSize )
{
m_VB ->Lock ( in_vertSize );
memcpy( m_VB->GetBuffer(), in_preVB, sizeof(DIFFUSETEXVERTEX) * in_vertSize );
m_VB ->Unlock ();
m_vertexCount = in_vertSize;
return;
}
void FX_CAuraRenderer::LockIB ( WORD *in_preIB,
const int in_indexSize )
{
WORD *buffer;
WORD *word = in_preIB;
WORD base = (WORD)m_VB ->GetBase ();
m_IB ->Lock ();
buffer = (WORD *)m_IB ->GetBuffer ();
for ( int index = 0; \
index < in_indexSize; \
++index, ++buffer, ++word )
{
(*buffer) = (*word) + base;
}
m_IB ->Unlock();
m_indexCount = in_indexSize;
return;
}
void FX_CAuraRenderer::Render ( int *in_numprims )
{
m_pd3dDevice ->SetRenderState( D3DRS_LIGHTING, FALSE );
m_D3DRender ->RenderDefault ( m_VB ->GetBase (),
m_vertexCount,
0,
(*in_numprims) * 3 );
m_pd3dDevice ->SetRenderState( D3DRS_LIGHTING, TRUE );
return;
}
void FX_CAuraRenderer::ShaderRender ( Fx_CHARACTER_t *in_char,
const int in_shaderRef,
int *in_numprims )
{
m_pd3dDevice ->SetRenderState ( D3DRS_LIGHTING, FALSE );
shader_t *thisShader = &m_shaderMng ->m_shaders[ in_shaderRef ];
#ifdef _FX_CLIENT
if ( thisShader ->flags & SHADER_TCGEN )
m_shaderMng ->PrepareTCGen ( thisShader, in_char ->position );
#endif
m_D3DRender ->RenderMDLCustom ( thisShader, m_VB ->GetBase (), m_vertexCount, 0, (*in_numprims) * 3 );
m_pd3dDevice ->SetRenderState ( D3DRS_LIGHTING, TRUE );
return;
}
| C++ |
#ifndef _SKIN_RENDERER_H_QOIHF32HR0HE20
#define _SKIN_RENDERER_H_QOIHF32HR0HE20
class FX_CSkinRenderer
{
public:
FX_CSkinRenderer ();
~FX_CSkinRenderer () {};
public:
CD3DBuffer *m_charVB[ MAX_CHAR_A_SCENE ];
CD3DBuffer *m_charIB[ MAX_CHAR_A_SCENE ];
CD3DBuffer *m_creatureVB[ MAX_CREATURE_A_SCENE ];
CD3DBuffer *m_creatureIB[ MAX_CREATURE_A_SCENE ];
LPDIRECT3DDEVICE8 m_pd3dDevice;
int m_iCurNumVertices;
int m_iCurNumPrimitives;
int m_iCurBaseIndex;
CD3DRender *m_D3DRender;
CShaderMng *m_shaderMng;
KEYFRAME *m_pInterpolatedFrame;
VERTEXMAP *m_pVertexMap;
INFLUENCE *m_pInfluence;
BONEINFLUENCE *m_pBoneInfluence;
FLOAT m_fWeight;
TEXTUREVERTEX *m_pVertices;
WORD *m_pIndices;
FX_CSkelManager *m_pSkelManager;
TEXTUREVERTEX m_vertexBuffer[ VERTEX_BUFFER_SIZE ];
public:
bool CreateBuffers();
void ReleaseBuffers();
bool TransformMesh ( Fx_CHARACTER_t *in_char, const FX_CMesh *pMesh, const KEYFRAME *pKeyFrames,
const int in_sysVBNum, const int in_skinPartID );
bool PrepareRender();
bool Render ( Fx_CHARACTER_t *in_char, int *in_numprims, const int in_skinPartIdx );
void ShaderRender ( Fx_CHARACTER_t *in_char, const int in_shaderRef, int *in_numprims, const int in_skinPartIdx );
void Cleanup();
void SetDevice ( LPDIRECT3DDEVICE8 device );
void SetRenderer ( CD3DRender *d3dRender ) { m_D3DRender = d3dRender; }
void SetShaderMng ( CShaderMng *shaderMng ) { m_shaderMng = shaderMng; };
void SetSkelManager ( FX_CSkelManager *skelManager ) { m_pSkelManager = skelManager; }
void SetIndices ( Fx_CHARACTER_t *in_char, const FACEINDEX *in_indices, const int in_numIndices, const int in_skinPartIdx );
void CopyVertex ( Fx_CHARACTER_t *in_char, TEXTUREVERTEX *in_sysVB, const int in_sysVBNum, const int in_skelPartIdx );
void RenderShadow ( Fx_CHARACTER_t *in_char, FX_CSkinManager *skinManager );
void SetStreamSource ( Fx_CHARACTER_t *in_char, const int in_streamIdx );
void DiscardIndexBuffer ( Fx_CHARACTER_t *in_char );
void DiscardVertexBuffer ( Fx_CHARACTER_t *in_char );
LPDIRECT3DINDEXBUFFER8 GetIndexBuffer ( Fx_CHARACTER_t *in_char );
private:
bool Initialize();
};
#endif
| C++ |
#ifndef _ITEM_RENDERER_H_HGF02H032HR
#define _ITEM_RENDERER_H_HGF02H032HR
class FX_CItemRenderer
{
public:
FX_CItemRenderer ();
~FX_CItemRenderer () {};
private:
CD3DBuffer *m_VB;
CD3DBuffer *m_IB;
LPDIRECT3DDEVICE8 m_pd3dDevice;
FX_CItemManager *m_pItemManager;
CD3DRender *m_D3DRender;
public:
bool CreateBuffers ();
bool FillBuffers ();
void ReleaseBuffers ();
bool Render ( const UINT &iVertexStart, const UINT &iNumVertex, const UINT &iIndexStart, const UINT &iPrimitiveCount );
bool PrepareRender ();
void SetWorldMatrix ( matrix4x4_t &matWorld );
void Cleanup ();
void SetDevice ( LPDIRECT3DDEVICE8 device ) { m_pd3dDevice = device; }
void SetItemManager ( FX_CItemManager *itemManager ) { m_pItemManager = itemManager; };
void SetRenderer ( CD3DRender *d3dRender ) { m_D3DRender = d3dRender; };
void RenderShadow ( Fx_CHARACTER_t *in_char, FX_CItemManager *itemManager, FX_CBoneManager *m_pBoneManager, matrix4x4_t *in_transform );
private:
bool Initialize();
};
#endif | C++ |
#ifndef _FX_AURA_RENDERER_H_AKJSHD34998Y4R
#define _FX_AURA_RENDERER_H_AKJSHD34998Y4R
class FX_CAuraRenderer
{
public:
FX_CAuraRenderer ();
~FX_CAuraRenderer () {};
public:
CD3DBuffer *m_VB;
CD3DBuffer *m_IB;
LPDIRECT3DDEVICE8 m_pd3dDevice;
int m_vertexCount;
int m_indexCount;
FX_CAuraManager *m_pAuraManager;
CShaderMng *m_shaderMng;
CD3DRender *m_D3DRender;
public:
bool CreateBuffers ();
bool FillBuffers ();
void ReleaseBuffers ();
bool PrepareRender ();
void Cleanup ();
void LockVB ( DIFFUSETEXVERTEX *in_preVB, const int in_vertSize );
void LockIB ( WORD *in_preIB, const int in_indexSize );
void Render ( int *in_numprims );
void SetDevice ( LPDIRECT3DDEVICE8 device ) { m_pd3dDevice = device; };
int GetBaseVertexIndex () { return m_VB ->GetBase (); };
void SetRenderer ( CD3DRender *d3dRender ) { m_D3DRender = d3dRender; };
void SetShaderMng ( CShaderMng *shaderMng ) { m_shaderMng = shaderMng; };
void ShaderRender ( Fx_CHARACTER_t *in_char, const int in_shaderRef, int *in_numprims );
private:
bool Initialize();
};
#endif | C++ |
#ifndef SKILL_TABLE_DATADEFINE_H
#define SKILL_TABLE_DATADEFINE_H
#define MAX_COUNT_AFFECT_DATA 5
#define MAX_COUNT_AFFECT_SPE_DATA 8
#define MAX_SKILL_CAST_COOL_SIZE 12
#define MAX_SKILL_ATTACK_TYPE 16
#define MAX_SKILL_AFFECT_TYPE 11
#define SKILL_AFFECT_TOGGLE_DEFAULT_DELAY_TIME 1000
#define SAFE_DIVIDE(a,b,c) (a != 0 && b !=0 ) ? ( c = ( a / b )) : c = 0
#define MAX_SKILL_CHECK_FLAG 5
#define MAX_SKILL_SUB_ACTION 3
#define MAX_SKILL_VALUE_LIST 10
#define MAX_SKILL_PARTY_CHECK 3
#define MAX_SKILL_MESSAGE_DATA 6
class CSkillDataValue
{
public:
CSkillDataValue()
{
Init();
}
void Init()
{
m_Type =0;
m_nIndex=0;
}
public:
BYTE m_Type;
int m_nIndex;
};
class CSkillDataCast
{
public:
CSkillDataCast()
{
Init();
}
~CSkillDataCast()
{
}
void Init()
{
m_Type =0;
}
public:
BYTE m_Type;
};
class CSkillDataCommon
{
public:
CSkillDataCommon()
{
Init();
}
void Init()
{
int i=0;
for(i=0;i<MAX_COUNT_AFFECT_DATA;i++)
{
m_Data[i].Init();
m_OnceData[i].Init();
}
m_bUse=false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
CSkillDataValue m_Data[MAX_COUNT_AFFECT_DATA];
CSkillDataValue m_OnceData[MAX_COUNT_AFFECT_DATA];
};
class CSkillDataFormat_Attack
{
public:
enum
{
MAX_SKILL_ATTACK_ETC_DATA=3,
};
CSkillDataFormat_Attack()
{
Init();
}
void Init()
{
m_AtkType =0;
m_HitPower =0;
m_HitRate =0;
m_PhyMinDmg =0;
m_PhyMaxDmg =0;
m_PosMinDmg =0;
m_PosMaxDmg =0;
m_NegMinDmg =0;
m_NegMaxDmg =0;
m_CriticalRate =0;
m_CriticalDamage=0;
m_DelayTime =0;
m_RepeatNum =0;
m_RepeatDelayTime=0;
m_EtcType=0;
for(int i=0;i<MAX_SKILL_ATTACK_ETC_DATA;i++)
{
m_EtcData[i].Init();
}
m_bUse =false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_AtkType;
BYTE m_HitPower;
BYTE m_HitRate;
BYTE m_PhyMinDmg;
BYTE m_PhyMaxDmg;
BYTE m_PosMinDmg;
BYTE m_PosMaxDmg;
BYTE m_NegMinDmg;
BYTE m_NegMaxDmg;
BYTE m_CriticalRate;
BYTE m_CriticalDamage;
BYTE m_DelayTime;
BYTE m_RepeatNum;
BYTE m_RepeatDelayTime;
BYTE m_EtcType;
CSkillDataValue m_EtcData[MAX_SKILL_ATTACK_ETC_DATA];
};
class CSkillDataAffectSpe
{
public:
CSkillDataAffectSpe()
{
Init();
}
void Init()
{
for(int i=0;i<MAX_COUNT_AFFECT_SPE_DATA;i++)
{
m_Data[i].Init();
}
m_bUse=false;
m_SpecialIdx=0;
m_SpecialType=0;
m_IsTransform=0;
m_TransformEntityIndex=0;
m_TransformType=0;
m_bUse=false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_SpecialType;
BYTE m_SpecialIdx;
BYTE m_IsTransform;
int m_TransformEntityIndex;
BYTE m_TransformType;
CSkillDataValue m_Data[MAX_COUNT_AFFECT_SPE_DATA];
};
class CSkillDataFormat_Affect
{
public:
CSkillDataFormat_Affect()
{
Init();
}
void Init()
{
m_Type =0;
m_AffectType =0;
m_StartTime =0;
m_KeepTime =0;
m_Level =0;
m_HitRate =0;
m_SkillTableIdx =0;
m_RaCostPerSec =0;
m_SaCostPerSec =0;
m_DelayTime =0;
m_Group =0;
m_GroupLevel =0;
m_bUse =false;
}
CSkillDataCommon *GetCommon()
{
return &m_Common;
}
CSkillDataAffectSpe *GetSpe()
{
return &m_Spe;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_Type;
BYTE m_AffectType;
BYTE m_StartTime;
BYTE m_KeepTime;
BYTE m_Level;
BYTE m_HitRate;
BYTE m_SkillTableIdx;
BYTE m_RaCostPerSec;
BYTE m_SaCostPerSec;
BYTE m_DelayTime;
BYTE m_Group;
BYTE m_GroupLevel;
CSkillDataCommon m_Common;
CSkillDataAffectSpe m_Spe;
};
class CSkillData_Message
{
public:
CSkillData_Message()
{
Init();
}
~CSkillData_Message()
{
}
void Init()
{
m_Type=0;
m_FromIdx=0;
m_FromType=0;
m_Name=0;
m_ToType=0;
m_ToIdx=0;
m_WorldIdx=0;
m_SendTime=0;
m_ReceiveTime=0;
int i;
for(i=0;i<MAX_SKILL_MESSAGE_DATA;i++) m_Data[i].Init();
}
public:
BYTE m_Type;
BYTE m_FromIdx;
BYTE m_FromType;
BYTE m_Name;
BYTE m_ToType;
BYTE m_ToIdx;
BYTE m_WorldIdx;
BYTE m_SendTime;
BYTE m_ReceiveTime;
CSkillDataValue m_Data[MAX_SKILL_MESSAGE_DATA];
};
class CSkillDataSubACtion
{
public:
CSkillDataSubACtion()
{
Init();
}
~CSkillDataSubACtion()
{
}
void Init()
{
m_Type=0;
m_fValue=0.0f;
}
public:
BYTE m_Type;
float m_fValue;
};
#define MAX_SKILL_PARTY_CHECK 3
class CSkillDataParty
{
public:
CSkillDataParty()
{
Init();
}
~CSkillDataParty()
{
}
void Init()
{
m_Type=0;
for(int i=0;i<MAX_SKILL_PARTY_CHECK;i++)
{
m_Check[i]=0;
}
}
public:
BYTE m_Type;
BYTE m_Check[MAX_SKILL_PARTY_CHECK];
};
class CSkillDataFormat
{
public:
enum
{
MAX_NUM_OF_DATA=3
};
CSkillDataFormat()
{
Init();
}
void Init()
{
m_InfoType =0;
m_TargetType =0;
m_TargetIdx =0;
m_MultiSkill =0;
m_MessageType =0;
m_ClassType =0;
m_Attack.Init();
m_Affect.Init();
m_Message.Init();
int i;
for(i=0;i<MAX_SKILL_CHECK_FLAG;i++) m_CheckFlag[i] = 0;
for(i=0;i<MAX_NUM_OF_DATA;i++) m_Data[i] = 0;
for(i=0;i<MAX_SKILL_SUB_ACTION;i++)
{
m_SubAtion[i].m_Type = 0;
m_SubAtion[i].m_fValue = 0;
}
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
m_ValueList[i].Init();
}
}
CSkillDataFormat_Attack *GetAttack()
{
return &m_Attack;
}
CSkillDataFormat_Affect *GetAffect()
{
return &m_Affect;
}
CSkillData_Message *GetMessage()
{
return &m_Message;
}
CSkillDataCast *GetCast()
{
return &m_Cast;
}
CSkillDataValue *GetValue(int index)
{
if(index <0 || index >= MAX_SKILL_VALUE_LIST ) return NULL;
return &m_ValueList[index];
}
bool DeleteValue(int index)
{
if(index <0 || index >= MAX_SKILL_VALUE_LIST ) return false;
m_ValueList[index].Init();
for(int i=index;i<MAX_SKILL_VALUE_LIST-1;i++)
{
m_ValueList[i] = m_ValueList[i+1];
}
m_ValueList[MAX_SKILL_VALUE_LIST-1].Init();
return true;
}
void ClearValueList()
{
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
m_ValueList[i].Init();
}
}
bool InsertValue(CSkillDataValue &value)
{
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(!m_ValueList[i].m_Type)
{
m_ValueList[i] = value;
return true;
}
}
return false;
}
CSkillDataParty * GetParty()
{
return &m_Party;
}
public:
BYTE m_InfoType;
BYTE m_TargetType;
BYTE m_TargetIdx;
BYTE m_ClassType;
BYTE m_MessageType;;
BYTE m_MultiSkill;
BYTE m_CheckFlag[MAX_SKILL_CHECK_FLAG];
BYTE m_Data[MAX_NUM_OF_DATA];
CSkillDataValue m_ValueList[MAX_SKILL_VALUE_LIST];
CSkillDataSubACtion m_SubAtion[MAX_SKILL_SUB_ACTION];
CSkillDataFormat_Attack m_Attack;
CSkillDataFormat_Affect m_Affect;
CSkillData_Message m_Message;
CSkillDataCast m_Cast;
CSkillDataParty m_Party;
};
class CSkillCastValue
{
public:
CSkillCastValue()
{
Init();
}
void Init()
{
m_nIndex=0;
m_nSa_Comsumption=0;
m_fCasting_Time=0;
m_fCool_Time=0.0f;
}
public:
int m_nIndex;
int m_nSa_Comsumption;
float m_fCasting_Time;
float m_fCool_Time;
};
class CSkillCastData
{
public:
CSkillCastData()
{
}
~CSkillCastData()
{
Clear();
}
bool Insert(int nID, CSkillCastValue *pTemp)
{
int _Type = nID / 100;
if(_Type < 0 || _Type >= MAX_SKILL_NUMBER) return false;
m_List[_Type].push_back(pTemp);
return true;
}
CSkillCastValue * Get(int nID)
{
int Type = nID / 100;
int index = (nID % 100)-1;
if(Type < 0 || Type >= MAX_SKILL_NUMBER) return NULL;
if(index <0 || index >= m_List[Type].size()) return NULL;
return m_List[Type][index];
}
void Clear()
{
for(int i=0;i<MAX_SKILL_NUMBER;i++)
{
int size = m_List[i].size();
for(int j=0;j<size;j++)
{
CSkillCastValue *temp = m_List[i][j];
SAFE_DELETE(temp);
}
m_List[i].clear();
}
}
public:
vector <CSkillCastValue *> m_List[MAX_SKILL_NUMBER];
};
class CSkillTableData
{
public:
CSkillTableData()
{
m_nLine =0;
m_bType =0;
m_nIndex =0;
m_fValue =0;
m_bGenGrade =0;
m_bGenCapablity=0;
m_bMaxLv =0;
}
public:
int m_nLine;
BYTE m_bType;
int m_nIndex;
float m_fValue;
BYTE m_bGenGrade;
BYTE m_bGenCapablity;
BYTE m_bMaxLv;
};
class CSkillDataTableList
{
public:
CSkillDataTableList()
{
}
~CSkillDataTableList()
{
Clear();
}
bool Insert(int _Type, CSkillTableData *pTemp)
{
if(_Type < 0 || _Type >= NUM_SKILL_TYPE) return false;
m_List[_Type].push_back(pTemp);
return true;
}
CSkillTableData * Get(int Type,int index)
{
if(Type < 0 || Type >= NUM_SKILL_TYPE) return NULL;
if(index <0 || index >= m_List[Type].size()) return NULL;
return m_List[Type][index];
}
void Clear()
{
for(int i=0;i<NUM_SKILL_TYPE;i++)
{
int size = m_List[i].size();
for(int j=0;j<size;j++)
{
CSkillTableData *temp = m_List[i][j];
SAFE_DELETE(temp);
}
m_List[i].clear();
}
}
public:
vector <CSkillTableData *> m_List[NUM_SKILL_TYPE];
};
#endif | C++ |
#include "../global_def.h"
CSkillDataGlobal g_SkillDataGlobal;
CSkillCastData g_SkillCastDataList;
CSkillDataTableList g_SkillDataTableList;
CSkillDataGlobal::CSkillDataGlobal()
{
}
CSkillDataGlobal::~CSkillDataGlobal()
{
Clear();
}
void CSkillDataGlobal::Clear()
{
g_SkillCastDataList.Clear();
g_SkillDataTableList.Clear();
g_SkillTableDB.ClearDB();
}
CSkillTableData * CSkillDataGlobal::GetValue(BYTE _Type,int _nSkillID,int _nMySkillIndex,int nSkillLevel)
{
int nSkillID=_nSkillID;
int nMySkillIndex=_nMySkillIndex;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(nSkillID);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return NULL;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type == _Type)
{
CSkillTableData *pTable = g_SkillDataTableList.Get(_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL)
{
break;
}
int GenLevel = CHARACTER_DEFAULT_GEN_LEVEL;
if(nSkillLevel > 0)
{
GenLevel = nSkillLevel;
}
else if(pTable->m_bGenGrade != J_NONE)
{
GenLevel = g_cgv.myCharacterInfo->skill[nMySkillIndex].level.gen[pTable->m_bGenGrade];
}
if(pTable->m_bMaxLv < GenLevel)
{
GenLevel = pTable->m_bMaxLv;
}
if(GenLevel <= 0) GenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
if(GenLevel ==CHARACTER_DEFAULT_GEN_LEVEL)
{
return pTable;
}
else
{
CSkillTableData *pvalue =
g_SkillDataTableList.Get(_Type,pDataFormat->m_ValueList[i].m_nIndex-1+GenLevel-CHARACTER_DEFAULT_GEN_LEVEL);
if(pvalue == NULL)
{
break;
}
return pvalue;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return NULL;
}
int CSkillDataGlobal::GetGenLevel(void *pPc,int nSkillID,int _nMySkillIdx)
{
return CHARACTER_DEFAULT_GEN_LEVEL;
}
int CSkillDataGlobal::GetGrade(int pcJob)
{
switch(pcJob)
{
case J_MENTALITY:
case J_DEVOTIONAL_KNIGHT:
case J_ROMING_KNIGHT:
return J_MENTALITY;
case J_WIND :
case J_PIECING_EYES:
case J_WINDY_ROMER:
return J_WIND;
case J_WATER:
case J_DESTROYER:
case J_GUARDIAN:
return J_WATER;
case J_EARTH:
case J_TRANSFORMER:
case J_DEFENDER:
return J_EARTH;
}
return -1;
}
CSkillCastValue * CSkillDataGlobal::GetCastValue(int _Type,int skillTableIdx,int nLevel)
{
if(skillTableIdx < 0 && skillTableIdx >= MAX_NUMBER_OF_SKILL)
{
return NULL;
}
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return NULL;
CSkillCastValue *pTable =NULL;
int i;
int GenLevel=CHARACTER_DEFAULT_GEN_LEVEL,MaxGenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
if(pDataFormat->m_ValueList[i].m_Type == SKILL_CAST_TABLE_INDEX) continue;
int nGrade = GetGrade(g_cgv.myCharacterInfo->pcJob);
if(nGrade <0) continue;
GenLevel=nLevel;
if(GenLevel <= 0) GenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
if(MaxGenLevel < GenLevel)
{
MaxGenLevel = GenLevel;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type == _Type)
{
pTable = g_SkillCastDataList.Get(pDataFormat->m_ValueList[i].m_nIndex);
if(pTable == NULL)
{
return NULL;
}
CSkillCastValue *pLevelValue =
g_SkillCastDataList.Get(pDataFormat->m_ValueList[i].m_nIndex+(MaxGenLevel-CHARACTER_DEFAULT_GEN_LEVEL));
if(pLevelValue == NULL) return pTable;
return pLevelValue;
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return NULL;
}
int CSkillDataGlobal::GetLimitlevel(int skillTableIdx,int nGenType)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return 0;
int nGenLevel=0;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
CSkillTableData *pTable = g_SkillDataTableList.Get(pDataFormat->m_ValueList[i].m_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL) continue;
if(pTable->m_bMaxLv > nGenLevel)
{
nGenLevel = pTable->m_bMaxLv;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return nGenLevel;
}
int CSkillDataGlobal::GetGradeClass(int skillTableIdx,int nGenType)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return 0;
int nGenCapablity=0;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
if( pDataFormat->m_ValueList[i].m_Type == SKILL_CAST_TABLE_INDEX) continue;
CSkillTableData *pTable = g_SkillDataTableList.Get(pDataFormat->m_ValueList[i].m_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL) continue;
if(pTable->m_bGenGrade == nGenType && pTable->m_bGenCapablity > nGenCapablity)
{
nGenCapablity = pTable->m_bGenCapablity;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return nGenCapablity;
}
| C++ |
#if !defined(AFX_SKILLFILE_H__E0CC4C4B_3A0E_41FA_B42A_EF517E955D53__INCLUDED_)
#define AFX_SKILLFILE_H__E0CC4C4B_3A0E_41FA_B42A_EF517E955D53__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillFile
{
public:
BYTE *m_Buffer;
public:
CSkillFile();
virtual ~CSkillFile();
bool GetData(void *p,int size);
int LoadSkillTable( char *filename);
bool CheckSize(int Val , LPSTR str);
bool LoadSkillTableCheckValue();
bool LoadSkillTableCheckSize();
void DebugOutString(LPCTSTR lpszFormat, ...);
};
extern CSkillFile g_SkillFile;
#endif
| C++ |
#if !defined(AFX_SKILLDATAGLOBAL_H__F408CB5B_CC06_470D_A4BC_1970931C1288__INCLUDED_)
#define AFX_SKILLDATAGLOBAL_H__F408CB5B_CC06_470D_A4BC_1970931C1288__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define CHARACTER_DEFAULT_GEN_LEVEL 1
class CSkillDataGlobal
{
public:
CSkillDataGlobal();
virtual ~CSkillDataGlobal();
public:
CSkillTableData * GetValue(BYTE _Type,int _nSkillID,int _nMySkillIndex,int nSkillLevel);
int GetGenLevel(void *pPc,int nSkillID,int AttrGen);
CSkillCastValue * GetCastValue(int _Type,int skillTableIdx,int nLevel=-1);
int GetGrade(int pcJob);
int GetLimitlevel(int skillTableIdx,int nGenType);
int GetGradeClass(int skillTableIdx,int nGenType);
void Clear();
};
extern CSkillCastData g_SkillCastDataList;
extern CSkillDataTableList g_SkillDataTableList;
extern CSkillDataGlobal g_SkillDataGlobal;
#endif
| C++ |
#include "../global_def.h"
CSkillItem g_SkillItem;
CSkillItem::CSkillItem()
{
}
CSkillItem::~CSkillItem()
{
}
bool CSkillItem::IfSkillItem(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return false;
return true;
}
void CSkillItem::SetDataList()
{
int size = m_SkillItemData.m_SkillItemList.size();
for(int i=0;i<size;i++)
{
CSkillItemSet *pSet= m_SkillItemData.Get(i);
if(pSet)
{
for(int j=0;j<MAX_SKILLITEM_UNIT;j++)
{
if(pSet->m_ItemList[j].m_nItemTableIdx)
{
m_mapSkillItem.insert(CMap_SkillItemData::value_type(
pSet->m_ItemList[j].m_nItemTableIdx,
i));
}
else
{
break;
}
}
}
}
}
int CSkillItem::GetSkillTableIndex(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return -1;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return -1;
return pSet->m_nSkillID;
}
int CSkillItem::GetLevel(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return -1;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return -1;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSet->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSet->m_ItemList[i].m_nItemTableIdx == itemTableIdx)
{
return pSet->m_ItemList[i].m_nLevel;
}
}
return -1;
}
bool CSkillItem::CheckValid_UseSkillItem(const int _invenPos)
{
int itemIdx = g_cgv.myCharacterInfo->inventory[_invenPos];
if ( itemIdx < 0 ) return false;
item_t *item = &g_cgv.myCharacterInfo->item[itemIdx];
if ( item == NULL) return false;
int skillTableIdx = GetSkillTableIndex(item->itemTableIdx);
if(skillTableIdx < 0) return false;
g_SkillFile.DebugOutString("CheckValid_UseSkillItem");
if(!g_SkillLogic.GTH_SkillProcess(globalVariable_t::SELECT_ITEM,_invenPos))
{
return false;
}
return true;
}
int CSkillItem::GetSkillItemTableIndex(int InvenPos)
{
if(InvenPos < 0) return -1;
int itemIdx = g_cgv.myCharacterInfo->inventory[InvenPos];
if ( itemIdx < 0 ) return -1;
item_t *item = &g_cgv.myCharacterInfo->item[itemIdx];
if ( item == NULL) return -1;
return g_SkillItem.GetSkillTableIndex(item->itemTableIdx);
}
bool CSkillItem::IsType(int itemTableIdx, int Type)
{
CSkillItemSet * pSkillItem= GetSkillItem(itemTableIdx);
if(NULL == pSkillItem) return false;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSkillItem->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSkillItem->m_ItemList[i].m_nType == Type)
{
return true;
}
}
return false;
}
CSkillItemSet * CSkillItem::GetSkillItem(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return NULL;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return NULL;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSet->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSet->m_ItemList[i].m_nItemTableIdx == itemTableIdx)
{
return pSet;
}
}
return NULL;
}
| C++ |
#if !defined(AFX_SKILLTABLEMAP_H__43AFC84D_AEC8_4BD1_9965_C61D49301226__INCLUDED_)
#define AFX_SKILLTABLEMAP_H__43AFC84D_AEC8_4BD1_9965_C61D49301226__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillTableMap
{
public:
CSkillTableMap();
~CSkillTableMap();
bool SAFE_ARRAY(int index);
int GetID(int index);
void ClearDB();
CSkilTable * FindDB(int nID);
void InsertDB(int nID, CSkilTable *pData);
std::vector <int> m_SkillList;
std::vector <CSkilTable *> m_SkillDB;
LPSTR GetSkillName(int index);
};
extern CSkillTableMap g_SkillTableDB;
#endif
| C++ |
#if !defined(AFX_SKILLTRANSINFO_H__E2BEA656_07D6_4B99_AA4B_160158A63005__INCLUDED_)
#define AFX_SKILLTRANSINFO_H__E2BEA656_07D6_4B99_AA4B_160158A63005__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillTransformUnit
{
public:
CSkillTransformUnit()
{
Init();
}
~CSkillTransformUnit()
{
}
void Init()
{
m_nSkillID =-1;
m_nTransformEntityIdx=-1;
m_nEffectID=-1;
}
public:
int m_nSkillID;
int m_nTransformEntityIdx;
int m_nEffectID;
};
class CSkillTransformData
{
public:
CSkillTransformData()
{
}
~CSkillTransformData()
{
}
CSkillTransformUnit * Get(int Index);
void Insert(CSkillTransformUnit *temp);
void Clear();
int GetEffectID(const int _EntityIdx);
public:
vector <CSkillTransformUnit *> m_TransData;
};
class CSkillTransInfo
{
public:
CSkillTransformData m_TransList;
public:
CSkillTransInfo();
virtual ~CSkillTransInfo();
CSkillTransformData * Get()
{
return &m_TransList;
}
};
extern CSkillTransInfo g_SkillTransInfo;
#endif
| C++ |
#include "../global_def.h"
CSkillTransInfo g_SkillTransInfo;
CSkillTransInfo::CSkillTransInfo()
{
}
CSkillTransInfo::~CSkillTransInfo()
{
}
CSkillTransformUnit * CSkillTransformData::Get(int Index)
{
if(Index < 0 || Index >= m_TransData.size())
{
return NULL;
}
return m_TransData[Index];
}
void CSkillTransformData::Insert(CSkillTransformUnit *temp)
{
m_TransData.push_back(temp);
}
void CSkillTransformData::Clear()
{
int size = m_TransData.size();
for(int i=0;i<size;i++)
{
CSkillTransformUnit *temp = m_TransData[i];
SAFE_DELETE(temp);
}
m_TransData.clear();
}
int CSkillTransformData::GetEffectID(const int _EntityIdx)
{
int size = m_TransData.size();
for(int i=0;i<size;i++)
{
if(m_TransData[i]->m_nTransformEntityIdx == _EntityIdx)
{
return m_TransData[i]->m_nEffectID;
}
}
return -1;
}
| C++ |
#if !defined(AFX_SKILLAPP_H__1F4D6A97_F467_44B7_956C_A83C5DCF5D36__INCLUDED_)
#define AFX_SKILLAPP_H__1F4D6A97_F467_44B7_956C_A83C5DCF5D36__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
SKILL_ERROR_BATTLE_TEST=1,
SKILL_ERROR_BATTLE,
SKILL_ERROR_PK_DISABLE,
SKILL_ERROR_COOLTIME,
};
class CSkillApp
{
public:
int skillResendFlag;
public:
CSkillApp();
virtual ~CSkillApp();
int Recv_ProcessEventMessage_Skill();
int Recv_ProcessEventMessage_SkillCasting();
int GTH_SkillCastingProcess();
void GTH_Character_Skill( Fx_CHARACTER_t *character );
void GTH_Character_SkillCasting( Fx_CHARACTER_t* character );
void ActionProcess( int id );
int CheckActionTarget( int entityType = ENTITY_PC, int checkDistanceFlag = false );
};
extern CSkillApp g_SkillApp;
#endif
| C++ |
#include "../global_def.h"
CSkillTableMap g_SkillTableDB;
CSkillTableMap::CSkillTableMap()
{
}
CSkillTableMap::~CSkillTableMap()
{
ClearDB();
}
void CSkillTableMap::ClearDB()
{
int size = m_SkillDB.size();
for(int i=0;i<size;i++)
{
SAFE_DELETE(m_SkillDB[i]);
}
m_SkillDB.clear();
}
CSkilTable *CSkillTableMap::FindDB(int nID)
{
int size = m_SkillDB.size();
if(nID < 0 || nID >= size)
{
return NULL;
}
return m_SkillDB[nID];
}
void CSkillTableMap::InsertDB(int nID, CSkilTable *pData)
{
m_SkillDB.push_back(pData);
}
LPSTR CSkillTableMap::GetSkillName(int index)
{
if(index < 0 || index >= m_SkillDB.size()) return "NULL";
return g_LPACK.Get(LPACK_TYPE_SKILL,m_SkillDB[index]->m_NameIdx);
}
bool CSkillTableMap::SAFE_ARRAY(int index)
{
if(index < 0 || index >= m_SkillList.size()) return false;
return true;
}
int CSkillTableMap::GetID(int index)
{
if(!SAFE_ARRAY(index)) return -1;
return m_SkillList[index];
}
| C++ |
#if !defined(AFX_SKILLITEM_H__000E36C4_7627_4D3D_A8A5_00D611C82BBF__INCLUDED_)
#define AFX_SKILLITEM_H__000E36C4_7627_4D3D_A8A5_00D611C82BBF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define MAX_SKILLITEM_UNIT 10
class CSkillItemUnit
{
public:
CSkillItemUnit()
{
Init();
}
~CSkillItemUnit()
{
}
void Init()
{
m_nItemTableIdx = -1;
m_nLevel = -1;
m_nType=-1;
}
void Set(int Index,int Level,int nType=-1)
{
m_nItemTableIdx = Index;
m_nLevel = Level;
m_nType = nType;
}
public:
int m_nItemTableIdx;
int m_nLevel;
int m_nType;
};
class CSkillItemSet
{
public:
CSkillItemSet()
{
Init();
}
~CSkillItemSet()
{
}
void Init()
{
m_nSkillID=-1;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
m_ItemList[i].Init();
}
}
void Insert(CSkillItemUnit temp)
{
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(m_ItemList[i].m_nItemTableIdx < 0)
{
m_ItemList[i] = temp;
break;
}
}
}
void Delete(int Idx)
{
if(Idx <0 || Idx >= MAX_SKILLITEM_UNIT) return;
m_ItemList[Idx].Init();
for(int i=Idx;i<MAX_SKILLITEM_UNIT-1;i++)
{
m_ItemList[i] = m_ItemList[i+1];
}
m_ItemList[MAX_SKILLITEM_UNIT-1].Init();
}
int Size()
{
int count=0;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(m_ItemList[i].m_nItemTableIdx>= 0)
{
count ++;
}
}
return count;
}
public:
int m_nSkillID;
CSkillItemUnit m_ItemList[MAX_SKILLITEM_UNIT];
};
class CSkillItemData
{
public:
CSkillItemData()
{
}
~CSkillItemData()
{
}
CSkillItemSet * Get(int Index)
{
if(Index < 0 || Index >= m_SkillItemList.size())
{
return NULL;
}
return m_SkillItemList[Index];
}
void Insert(CSkillItemSet *temp)
{
m_SkillItemList.push_back(temp);
}
void Clear()
{
int size = m_SkillItemList.size();
for(int i=0;i<size;i++)
{
CSkillItemSet *temp = m_SkillItemList[i];
SAFE_DELETE(temp);
}
m_SkillItemList.clear();
}
public:
vector <CSkillItemSet *> m_SkillItemList;
};
class CSkillItem
{
public:
enum
{
ITEM_TYPE_NONE=0,
ITEM_TYPE_ENABLE_DEAD_SELF_ITEM,
ITEM_TYPE_TRANSFORM_ITEM,
NUM_OF_ITEM_TYPE,
};
CSkillItem();
virtual ~CSkillItem();
CSkillItemData * GetSkillItemList()
{
return &m_SkillItemData;
}
bool IfSkillItem(int itemTableIdx);
void SetDataList();
bool CheckValid_UseSkillItem(const int _InventoryIdx);
int GetSkillTableIndex(int itemTableIdx);
int GetLevel(int itemTableIdx);
int GetSkillItemTableIndex(int InvenPos);
CSkillItemSet * GetSkillItem(int itemTableIdx);
bool IsType(int itemTableIdx, int Type);
public:
typedef map<int , int> CMap_SkillItemData;
CMap_SkillItemData m_mapSkillItem;
CSkillItemData m_SkillItemData;
};
extern CSkillItem g_SkillItem;
#endif
| C++ |
#define STRICT
#include <stdio.h>
#include <tchar.h>
#include <D3DX8.h>
#include "D3DFont.h"
#include "D3DUtil.h"
#include "DXUtil.h"
#define MAX_NUM_VERTICES 50*6
struct FONT2DVERTEX { D3DXVECTOR4 p; DWORD color; FLOAT tu, tv; };
struct FONT3DVERTEX { D3DXVECTOR3 p; D3DXVECTOR3 n; FLOAT tu, tv; };
#define D3DFVF_FONT2DVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1)
#define D3DFVF_FONT3DVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)
inline FONT2DVERTEX InitFont2DVertex( const D3DXVECTOR4& p, D3DCOLOR color,
FLOAT tu, FLOAT tv )
{
FONT2DVERTEX v; v.p = p; v.color = color; v.tu = tu; v.tv = tv;
return v;
}
inline FONT3DVERTEX InitFont3DVertex( const D3DXVECTOR3& p, const D3DXVECTOR3& n,
FLOAT tu, FLOAT tv )
{
FONT3DVERTEX v; v.p = p; v.n = n; v.tu = tu; v.tv = tv;
return v;
}
CD3DFont::CD3DFont( TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags )
{
_tcscpy( m_strFontName, strFontName );
m_dwFontHeight = dwHeight;
m_dwFontFlags = dwFlags;
m_pd3dDevice = NULL;
m_pTexture = NULL;
m_pVB = NULL;
m_dwSavedStateBlock = 0L;
m_dwDrawTextStateBlock = 0L;
}
CD3DFont::~CD3DFont()
{
InvalidateDeviceObjects();
DeleteDeviceObjects();
}
HRESULT CD3DFont::InitDeviceObjects( LPDIRECT3DDEVICE8 pd3dDevice )
{
HRESULT hr;
m_pd3dDevice = pd3dDevice;
m_fTextScale = 1.0f;
if( m_dwFontHeight > 40 )
m_dwTexWidth = m_dwTexHeight = 1024;
else if( m_dwFontHeight > 20 )
m_dwTexWidth = m_dwTexHeight = 512;
else
m_dwTexWidth = m_dwTexHeight = 256;
D3DCAPS8 d3dCaps;
m_pd3dDevice->GetDeviceCaps( &d3dCaps );
if( m_dwTexWidth > d3dCaps.MaxTextureWidth )
{
m_fTextScale = (FLOAT)d3dCaps.MaxTextureWidth / (FLOAT)m_dwTexWidth;
m_dwTexWidth = m_dwTexHeight = d3dCaps.MaxTextureWidth;
}
hr = m_pd3dDevice->CreateTexture( m_dwTexWidth, m_dwTexHeight, 1,
0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, &m_pTexture );
if( FAILED(hr) )
return hr;
DWORD* pBitmapBits;
BITMAPINFO bmi;
ZeroMemory( &bmi.bmiHeader, sizeof(BITMAPINFOHEADER) );
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = (int)m_dwTexWidth;
bmi.bmiHeader.biHeight = -(int)m_dwTexHeight;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biBitCount = 32;
HDC hDC = CreateCompatibleDC( NULL );
HBITMAP hbmBitmap = CreateDIBSection( hDC, &bmi, DIB_RGB_COLORS,
(VOID**)&pBitmapBits, NULL, 0 );
SetMapMode( hDC, MM_TEXT );
INT nHeight = -MulDiv( m_dwFontHeight,
(INT)(GetDeviceCaps(hDC, LOGPIXELSY) * m_fTextScale), 72 );
DWORD dwBold = (m_dwFontFlags&D3DFONT_BOLD) ? FW_BOLD : FW_NORMAL;
DWORD dwItalic = (m_dwFontFlags&D3DFONT_ITALIC) ? TRUE : FALSE;
HFONT hFont = CreateFont( nHeight, 0, 0, 0, dwBold, dwItalic,
FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
VARIABLE_PITCH, m_strFontName );
if( NULL==hFont )
return E_FAIL;
SelectObject( hDC, hbmBitmap );
SelectObject( hDC, hFont );
SetTextColor( hDC, RGB(255,255,255) );
SetBkColor( hDC, 0x00000000 );
SetTextAlign( hDC, TA_TOP );
DWORD x = 0;
DWORD y = 0;
TCHAR str[2] = _T("x");
SIZE size;
for( TCHAR c=32; c<127; c++ )
{
str[0] = c;
GetTextExtentPoint32( hDC, str, 1, &size );
if( (DWORD)(x+size.cx+1) > m_dwTexWidth )
{
x = 0;
y += size.cy+1;
}
ExtTextOut( hDC, x+0, y+0, ETO_OPAQUE, NULL, str, 1, NULL );
m_fTexCoords[c-32][0] = ((FLOAT)(x+0))/m_dwTexWidth;
m_fTexCoords[c-32][1] = ((FLOAT)(y+0))/m_dwTexHeight;
m_fTexCoords[c-32][2] = ((FLOAT)(x+0+size.cx))/m_dwTexWidth;
m_fTexCoords[c-32][3] = ((FLOAT)(y+0+size.cy))/m_dwTexHeight;
x += size.cx+1;
}
D3DLOCKED_RECT d3dlr;
m_pTexture->LockRect( 0, &d3dlr, 0, 0 );
BYTE* pDstRow = (BYTE*)d3dlr.pBits;
WORD* pDst16;
BYTE bAlpha;
for( y=0; y < m_dwTexHeight; y++ )
{
pDst16 = (WORD*)pDstRow;
for( x=0; x < m_dwTexWidth; x++ )
{
bAlpha = (BYTE)((pBitmapBits[m_dwTexWidth*y + x] & 0xff) >> 4);
if (bAlpha > 0)
{
*pDst16++ = (bAlpha << 12) | 0x0fff;
}
else
{
*pDst16++ = 0x00000000;
}
}
pDstRow += d3dlr.Pitch;
}
m_pTexture->UnlockRect(0);
DeleteObject( hbmBitmap );
DeleteDC( hDC );
DeleteObject( hFont );
return S_OK;
}
HRESULT CD3DFont::RestoreDeviceObjects()
{
HRESULT hr;
if( FAILED( hr = m_pd3dDevice->CreateVertexBuffer( MAX_NUM_VERTICES*sizeof(FONT2DVERTEX),
D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0,
D3DPOOL_DEFAULT, &m_pVB ) ) )
{
return hr;
}
for( UINT which=0; which<2; which++ )
{
}
return S_OK;
}
void CD3DFont::SetRenderState()
{
m_pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
m_pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , TRUE );
m_pd3dDevice->SetRenderState( D3DRS_ALPHAREF , 0x00 );
m_pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC , D3DCMP_GREATER );
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCALPHA );
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE , FALSE );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_SELECTARG2 );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG1 , D3DTA_TEXTURE );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
m_pd3dDevice->SetTextureStageState( 1 , D3DTSS_COLOROP , D3DTOP_DISABLE );
m_pd3dDevice->SetTextureStageState( 1 , D3DTSS_ALPHAOP , D3DTOP_DISABLE );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MINFILTER , D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0 , D3DTSS_MIPFILTER , D3DTEXF_NONE );
}
HRESULT CD3DFont::InvalidateDeviceObjects()
{
SAFE_RELEASE( m_pVB );
if( m_pd3dDevice )
{
if( m_dwSavedStateBlock )
m_pd3dDevice->DeleteStateBlock( m_dwSavedStateBlock );
if( m_dwDrawTextStateBlock )
m_pd3dDevice->DeleteStateBlock( m_dwDrawTextStateBlock );
}
m_dwSavedStateBlock = 0L;
m_dwDrawTextStateBlock = 0L;
return S_OK;
}
HRESULT CD3DFont::DeleteDeviceObjects()
{
SAFE_RELEASE( m_pTexture );
m_pd3dDevice = NULL;
return S_OK;
}
HRESULT CD3DFont::GetTextExtent( TCHAR* strText, SIZE* pSize )
{
if( NULL==strText || NULL==pSize )
return E_FAIL;
FLOAT fRowWidth = 0.0f;
FLOAT fRowHeight = (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
FLOAT fWidth = 0.0f;
FLOAT fHeight = fRowHeight;
while( *strText )
{
TCHAR c = *strText++;
if( c == _T('\n') )
{
fRowWidth = 0.0f;
fHeight += fRowHeight;
}
if( c < _T(' ') )
continue;
FLOAT tx1 = m_fTexCoords[c-32][0];
FLOAT tx2 = m_fTexCoords[c-32][2];
fRowWidth += (tx2-tx1)*m_dwTexWidth;
if( fRowWidth > fWidth )
fWidth = fRowWidth;
}
pSize->cx = (int)fWidth;
pSize->cy = (int)fHeight;
return S_OK;
}
HRESULT CD3DFont::DrawTextScaled( FLOAT x, FLOAT y, FLOAT z,
FLOAT fXScale, FLOAT fYScale, DWORD dwColor,
TCHAR* strText, DWORD dwFlags )
{
if( m_pd3dDevice == NULL )
return E_FAIL;
m_pd3dDevice->SetTexture( 0, m_pTexture );
SetRenderState();
m_pd3dDevice->SetVertexShader( D3DFVF_FONT2DVERTEX );
m_pd3dDevice->SetPixelShader( NULL );
m_pd3dDevice->SetStreamSource( 0, m_pVB, sizeof(FONT2DVERTEX) );
D3DVIEWPORT8 vp;
m_pd3dDevice->GetViewport( &vp );
FLOAT sx = x;
FLOAT sy = y;
FLOAT sz = z;
FLOAT rhw = 1.0f;
FLOAT fStartX = sx;
FLOAT fLineHeight = ( m_fTexCoords[0][3] - m_fTexCoords[0][1] ) * m_dwTexHeight;
FONT2DVERTEX* pVertices;
DWORD dwNumTriangles = 0L;
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
while( *strText )
{
TCHAR c = *strText++;
if( c == _T('\n') )
{
sx = fStartX;
sy += fYScale*vp.Height;
}
if( c < _T(' ') )
continue;
FLOAT tx1 = m_fTexCoords[c-32][0];
FLOAT ty1 = m_fTexCoords[c-32][1];
FLOAT tx2 = m_fTexCoords[c-32][2];
FLOAT ty2 = m_fTexCoords[c-32][3];
FLOAT w = (tx2-tx1)*m_dwTexWidth;
FLOAT h = (ty2-ty1)*m_dwTexHeight;
w *= (fXScale*vp.Height)/fLineHeight;
h *= (fYScale*vp.Height)/fLineHeight;
if( c != _T(' ') )
{
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+h-0.5f,sz,rhw), dwColor, tx1, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,sz,rhw), dwColor, tx1, ty1 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,sz,rhw), dwColor, tx2, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+0-0.5f,sz,rhw), dwColor, tx2, ty1 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,sz,rhw), dwColor, tx2, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,sz,rhw), dwColor, tx1, ty1 );
dwNumTriangles += 2;
if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) )
{
m_pVB->Unlock();
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
dwNumTriangles = 0L;
}
}
sx += w;
}
m_pVB->Unlock();
if( dwNumTriangles > 0 )
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
return S_OK;
}
HRESULT CD3DFont::DrawText( FLOAT sx, FLOAT sy, DWORD dwColor,
TCHAR* strText, DWORD dwFlags )
{
if( m_pd3dDevice == NULL )
return E_FAIL;
m_pd3dDevice->SetTexture( 0, m_pTexture );
SetRenderState();
m_pd3dDevice->SetVertexShader( D3DFVF_FONT2DVERTEX );
m_pd3dDevice->SetPixelShader( NULL );
m_pd3dDevice->SetStreamSource( 0, m_pVB, sizeof(FONT2DVERTEX) );
{
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
}
FLOAT fStartX = sx;
FONT2DVERTEX* pVertices = NULL;
DWORD dwNumTriangles = 0;
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
while( *strText )
{
TCHAR c = *strText++;
if( c == _T('\n') )
{
sx = fStartX;
sy += (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
}
if( c < _T(' ') )
continue;
FLOAT tx1 = m_fTexCoords[c-32][0];
FLOAT ty1 = m_fTexCoords[c-32][1];
FLOAT tx2 = m_fTexCoords[c-32][2];
FLOAT ty2 = m_fTexCoords[c-32][3];
FLOAT w = (tx2-tx1) * m_dwTexWidth / m_fTextScale;
FLOAT h = (ty2-ty1) * m_dwTexHeight / m_fTextScale;
if( c != _T(' ') )
{
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx1, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx2, ty1 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
dwNumTriangles += 2;
if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) )
{
m_pVB->Unlock();
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
pVertices = NULL;
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
dwNumTriangles = 0L;
}
}
sx += w;
}
m_pVB->Unlock();
if( dwNumTriangles > 0 )
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
return S_OK;
}
HRESULT CD3DFont::DrawTexture( FLOAT sx, FLOAT sy, DWORD dwColor, DWORD dwFlags )
{
if( m_pd3dDevice == NULL )
return E_FAIL;
m_pd3dDevice->SetTexture( 0, m_pTexture );
SetRenderState();
m_pd3dDevice->SetVertexShader( D3DFVF_FONT2DVERTEX );
m_pd3dDevice->SetPixelShader( NULL );
m_pd3dDevice->SetStreamSource( 0, m_pVB, sizeof(FONT2DVERTEX) );
FONT2DVERTEX* pVertices = NULL;
DWORD dwNumTriangles = 2;
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
FLOAT w = (float)m_dwTexWidth;
FLOAT h = (float)m_dwTexHeight;
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, 0.0f, 1.0f );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, 0.0f, 0.0f );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, 1.0f, 1.0f );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, 1.0f, 0.0f );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, 1.0f, 1.0f );
*pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, 0.0f, 0.0f );
m_pVB->Unlock();
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
pVertices = NULL;
return S_OK;
}
HRESULT CD3DFont::Render3DText( TCHAR* strText, DWORD dwFlags )
{
if( m_pd3dDevice == NULL )
return E_FAIL;
m_pd3dDevice->CaptureStateBlock( m_dwSavedStateBlock );
m_pd3dDevice->ApplyStateBlock( m_dwDrawTextStateBlock );
m_pd3dDevice->SetVertexShader( D3DFVF_FONT3DVERTEX );
m_pd3dDevice->SetPixelShader( NULL );
m_pd3dDevice->SetStreamSource( 0, m_pVB, sizeof(FONT3DVERTEX) );
if( dwFlags & D3DFONT_FILTERED )
{
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
}
FLOAT x = 0.0f;
FLOAT y = 0.0f;
if( dwFlags & D3DFONT_CENTERED )
{
SIZE sz;
GetTextExtent( strText, &sz );
x = -(((FLOAT)sz.cx)/10.0f)/2.0f;
y = -(((FLOAT)sz.cy)/10.0f)/2.0f;
}
if( dwFlags & D3DFONT_TWOSIDED )
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
FLOAT fStartX = x;
TCHAR c;
FONT3DVERTEX* pVertices;
DWORD dwVertex = 0L;
DWORD dwNumTriangles = 0L;
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
while( c = *strText++ )
{
if( c == '\n' )
{
x = fStartX;
y -= (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight/10.0f;
}
if( c < 32 )
continue;
FLOAT tx1 = m_fTexCoords[c-32][0];
FLOAT ty1 = m_fTexCoords[c-32][1];
FLOAT tx2 = m_fTexCoords[c-32][2];
FLOAT ty2 = m_fTexCoords[c-32][3];
FLOAT w = (tx2-tx1) * m_dwTexWidth / ( 10.0f * m_fTextScale );
FLOAT h = (ty2-ty1) * m_dwTexHeight / ( 10.0f * m_fTextScale );
if( c != _T(' ') )
{
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+0,y+0,0), D3DXVECTOR3(0,0,-1), tx1, ty2 );
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+0,y+h,0), D3DXVECTOR3(0,0,-1), tx1, ty1 );
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+w,y+0,0), D3DXVECTOR3(0,0,-1), tx2, ty2 );
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+w,y+h,0), D3DXVECTOR3(0,0,-1), tx2, ty1 );
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+w,y+0,0), D3DXVECTOR3(0,0,-1), tx2, ty2 );
*pVertices++ = InitFont3DVertex( D3DXVECTOR3(x+0,y+h,0), D3DXVECTOR3(0,0,-1), tx1, ty1 );
dwNumTriangles += 2;
if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) )
{
m_pVB->Unlock();
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
m_pVB->Lock( 0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD );
dwNumTriangles = 0L;
}
}
x += w;
}
m_pVB->Unlock();
if( dwNumTriangles > 0 )
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
m_pd3dDevice->ApplyStateBlock( m_dwSavedStateBlock );
return S_OK;
}
| C++ |
#pragma comment ( lib, "imm32.lib" )
#include <windows.h>
#include <imm.h>
class CIme{
bool g_bIme;
char g_szCompStr[ MAX_PATH ];
char g_szCompReadStr[ MAX_PATH ];
char g_szCandList[ MAX_PATH ];
int g_nImeCursor;
CANDIDATELIST *g_lpCandList;
char g_szImeName[ 64 ];
bool g_bImeSharp;
bool g_bImeSymbol;
void ConvertCandList( CANDIDATELIST *pCandList, char *pszCandList );
public:
CIme() : g_lpCandList( NULL ){ DisableIme(); }
~CIme(){
DisableIme();
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
}
void DisableIme();
void EnableIme();
void NextIme();
void SharpIme( HWND hWnd );
void SymbolIme( HWND hWnd );
char* GetImeName();
bool IfImeSharp();
bool IfImeSymbol();
void GetImeInput( char **pszCompStr, char **pszCompReadStr, int *pnImeCursor, char **pszCandList );
bool OnWM_INPUTLANGCHANGEREQUEST();
bool OnWM_INPUTLANGCHANGE( HWND hWnd );
bool OnWM_IME_SETCONTEXT(){ return true; }
bool OnWM_IME_STARTCOMPOSITION(){ return true; }
bool OnWM_IME_ENDCOMPOSITION(){ return true; }
bool OnWM_IME_NOTIFY( HWND hWnd, WPARAM wParam );
bool OnWM_IME_COMPOSITION( HWND hWnd, LPARAM lParam );
};
void CIme::DisableIme(){
while( ImmIsIME( GetKeyboardLayout( 0 )))
ActivateKeyboardLayout(( HKL )HKL_NEXT, 0 );
g_bIme = false;
g_szImeName[ 0 ] = 0;
g_szCompStr[ 0 ] = 0;
g_szCompReadStr[ 0 ] = 0;
g_szCandList[ 0 ] = 0;
g_nImeCursor = 0;
}
void CIme::EnableIme(){
g_bIme = true;
}
void CIme::NextIme(){
if( g_bIme )ActivateKeyboardLayout(( HKL )HKL_NEXT, 0 );
}
void CIme::SharpIme( HWND hWnd ){
ImmSimulateHotKey( hWnd, IME_CHOTKEY_SHAPE_TOGGLE );
}
void CIme::SymbolIme( HWND hWnd ){
ImmSimulateHotKey( hWnd, IME_CHOTKEY_SYMBOL_TOGGLE );
}
void CIme::ConvertCandList( CANDIDATELIST *pCandList, char *pszCandList ){
unsigned int i;
if( pCandList->dwCount < pCandList->dwSelection ){
pszCandList[ 0 ] = 0;
return;
}
for( i = 0; ( i < pCandList->dwCount - pCandList->dwSelection )&&( i < pCandList->dwPageSize ); i++ ){
*pszCandList++ = ( i % 10 != 9 )? i % 10 + '1' : '0';
*pszCandList++ = '.';
strcpy( pszCandList, (char*)pCandList
+ pCandList->dwOffset[ pCandList->dwSelection + i ] );
pszCandList += strlen( pszCandList );
*pszCandList++ = '\t';
}
*( pszCandList - 1 )= 0;
}
bool CIme::OnWM_INPUTLANGCHANGEREQUEST(){
return !g_bIme;
}
bool CIme::OnWM_INPUTLANGCHANGE( HWND hWnd ){
HKL hKL = GetKeyboardLayout( 0 );
if( ImmIsIME( hKL )){
HIMC hIMC = ImmGetContext( hWnd );
ImmEscape( hKL, hIMC, IME_ESC_IME_NAME, g_szImeName );
DWORD dwConversion, dwSentence;
ImmGetConversionStatus( hIMC, &dwConversion, &dwSentence );
g_bImeSharp = ( dwConversion & IME_CMODE_FULLSHAPE )? true : false;
g_bImeSymbol = ( dwConversion & IME_CMODE_SYMBOL )? true : false;
ImmReleaseContext( hWnd, hIMC );
}
else
g_szImeName[ 0 ] = 0;
return false;
}
bool CIme::OnWM_IME_NOTIFY( HWND hWnd, WPARAM wParam ){
HIMC hIMC;
DWORD dwSize;
DWORD dwConversion, dwSentence;
switch( wParam ){
case IMN_SETCONVERSIONMODE:
hIMC = ImmGetContext( hWnd );
ImmGetConversionStatus( hIMC, &dwConversion, &dwSentence );
g_bImeSharp = ( dwConversion & IME_CMODE_FULLSHAPE )? true : false;
g_bImeSymbol = ( dwConversion & IME_CMODE_SYMBOL )? true : false;
ImmReleaseContext( hWnd, hIMC );
break;
case IMN_OPENCANDIDATE:
case IMN_CHANGECANDIDATE:
hIMC = ImmGetContext( hWnd );
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
if( dwSize = ImmGetCandidateList( hIMC, 0, NULL, 0 )){
g_lpCandList = (LPCANDIDATELIST)GlobalAlloc( GPTR, dwSize );
if( g_lpCandList )
ImmGetCandidateList( hIMC, 0, g_lpCandList, dwSize );
}
ImmReleaseContext( hWnd, hIMC );
if( g_lpCandList )ConvertCandList( g_lpCandList, g_szCandList );
break;
case IMN_CLOSECANDIDATE:
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
g_szCandList[ 0 ] = 0;
break;
}
return true;
}
bool CIme::OnWM_IME_COMPOSITION( HWND hWnd, LPARAM lParam ){
HIMC hIMC;
DWORD dwSize;
hIMC = ImmGetContext( hWnd );
if( lParam & GCS_COMPSTR ){
dwSize = ImmGetCompositionString( hIMC, GCS_COMPSTR, (void*)g_szCompStr, sizeof( g_szCompStr ));
g_szCompStr[ dwSize ] = 0;
}
if( lParam & GCS_COMPREADSTR ){
dwSize = ImmGetCompositionString( hIMC, GCS_COMPREADSTR, (void*)g_szCompReadStr, sizeof( g_szCompReadStr ));
g_szCompReadStr[ dwSize ] = 0;
}
if( lParam & GCS_CURSORPOS ){
g_nImeCursor = 0xffff & ImmGetCompositionString( hIMC, GCS_CURSORPOS, NULL, 0 );
}
if( lParam & GCS_RESULTSTR ){
unsigned char str[ MAX_PATH ];
dwSize = ImmGetCompositionString( hIMC, GCS_RESULTSTR, (void*)str, sizeof( str ));
str[ dwSize ] = 0;
unsigned char *p = str;
while( *p )PostMessage( hWnd, WM_CHAR, (WPARAM)(*p++), 1 );
}
ImmReleaseContext( hWnd, hIMC );
return true;
}
char* CIme::GetImeName(){
return g_szImeName[ 0 ]? g_szImeName : NULL;
}
bool CIme::IfImeSharp(){
return g_bImeSharp;
}
bool CIme::IfImeSymbol(){
return g_bImeSymbol;
}
void CIme::GetImeInput( char **pszCompStr, char **pszCompReadStr, int *pnImeCursor, char **pszCandList ){
if( pszCompStr )*pszCompStr = g_szCompStr;
if( pszCompReadStr )*pszCompReadStr = g_szCompReadStr;
if( pnImeCursor )*pnImeCursor = g_nImeCursor;
if( pszCandList )*pszCandList = g_szCandList;
}
| C++ |
#ifndef DIUTIL_H
#define DIUTIL_H
#include <dinput.h>
class CInputDeviceManager
{
public:
struct DeviceInfo
{
LPDIRECTINPUTDEVICE8 pdidDevice;
LPVOID pParam;
};
typedef HRESULT (CALLBACK *LPDIMANAGERCALLBACK)(CInputDeviceManager::DeviceInfo* pDeviceInfo, const DIDEVICEINSTANCE* pdidi, LPVOID);
private:
BOOL m_bCleanupCOM;
HWND m_hWnd;
TCHAR* m_strUserName;
LPDIRECTINPUT8 m_pDI;
DeviceInfo* m_pDevices;
DWORD m_dwMaxDevices;
DWORD m_dwNumDevices;
DIACTIONFORMAT m_diaf;
LPDIMANAGERCALLBACK m_AddDeviceCallback;
LPVOID m_AddDeviceCallbackParam;
public:
HRESULT AddDevice( const DIDEVICEINSTANCE* pdidi, LPDIRECTINPUTDEVICE8 pdidDevice );
HRESULT GetDevices( DeviceInfo** ppDeviceInfo, DWORD* pdwNumDevices );
HRESULT ConfigureDevices( HWND hWnd, IUnknown* pSurface, VOID* pCallback, DWORD dwFlags, LPVOID pvCBParam );
VOID UnacquireDevices();
VOID SetFocus( HWND hWnd );
HRESULT SetActionFormat( DIACTIONFORMAT& diaf, BOOL bReenumerate );
HRESULT Create( HWND hWnd, TCHAR* strUserName, DIACTIONFORMAT& diaf, LPDIMANAGERCALLBACK AddDeviceCallback, LPVOID pCallbackParam );
CInputDeviceManager();
~CInputDeviceManager();
};
#endif
| C++ |
#define STRICT
#include <windows.h>
#include <windowsx.h>
#include <basetsd.h>
#include <mmsystem.h>
#include <stdio.h>
#include <tchar.h>
#include <D3D8.h>
#include "D3DApp.h"
#include "D3DUtil.h"
#include "DXUtil.h"
#include "D3DRes.h"
#include "../resource.h"
#include "../game/ConfigApp.h"
static CD3DApplication* g_pD3DApp = NULL;
CD3DApplication::CD3DApplication()
{
g_pD3DApp = this;
m_dwNumAdapters = 0;
m_dwAdapter = 0L;
m_pD3D = NULL;
m_pd3dDevice = NULL;
m_hWnd = NULL;
m_hWndFocus = NULL;
m_bActive = FALSE;
m_bReady = FALSE;
m_bHasFocus = FALSE;
m_dwCreateFlags = 0L;
m_bFrameMoving = TRUE;
m_bSingleStep = FALSE;
m_fFPS = 0.0f;
m_strDeviceStats[0] = _T('\0');
m_strFrameStats[0] = _T('\0');
m_strWindowTitle = _T("Gate To Heavens");
m_dwCreationWidth = 400;
m_dwCreationHeight = 300;
m_bUseDepthBuffer = FALSE;
m_dwMinDepthBits = 16;
m_dwMinStencilBits = 0;
m_bShowCursorWhenFullscreen = FALSE;
m_bClipCursorWhenFullscreen = TRUE;
m_bAppExit = FALSE;
m_bChangeDisplay = FALSE;
}
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return g_pD3DApp->MsgProc( hWnd, uMsg, wParam, lParam );
}
HRESULT CD3DApplication::Create( HINSTANCE hInstance )
{
HRESULT hr;
m_pD3D = Direct3DCreate8( D3D_SDK_VERSION );
if( m_pD3D == NULL )
return DisplayErrorMsg( D3DAPPERR_NODIRECT3D, MSGERR_APPMUSTEXIT );
if( FAILED( hr = BuildDeviceList() ) )
{
SAFE_RELEASE( m_pD3D );
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
}
if( m_hWnd == NULL)
{
WNDCLASS wndClass = { 0 , WndProc, 0, 0, hInstance,
LoadIcon( hInstance, MAKEINTRESOURCE(IDI_GTH_ICON) ),
LoadCursor( NULL, IDC_ARROW ),
(HBRUSH)GetStockObject(BLACK_BRUSH),
NULL, _T("Gate To Heavens") };
wndClass.style |= CS_DBLCLKS;
if( !m_bWindowed )
wndClass.hbrBackground = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
RegisterClass( &wndClass );
//lucky 2012 Windowed
m_dwWindowStyle = WS_CAPTION|WS_MINIMIZEBOX|WS_SYSMENU;
//end
if( g_userConfig.resoution == 0 )
{
m_dwCreationWidth = 800;
m_dwCreationHeight = (600 - 50);
}
else if( g_userConfig.resoution == 1 )
{
m_dwCreationWidth = 1024;
m_dwCreationHeight = (768 - 50);
}
else if( g_userConfig.resoution == 2 )
{
m_dwCreationWidth = 1280;
m_dwCreationHeight = (1024 - 50);
}else if( g_userConfig.resoution == 3 )
{
m_dwWindowStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
m_dwCreationWidth = GetSystemMetrics(SM_CXSCREEN);
m_dwCreationHeight = GetSystemMetrics(SM_CYSCREEN);
}
if ( m_bFullScreen && m_bWindowed )
{
DEVMODE dm, dm2;
ZeroMemory(&dm, sizeof(DEVMODE));
ZeroMemory(&dm2, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
dm.dmDriverExtra = 0;
EnumDisplaySettings( NULL, ENUM_REGISTRY_SETTINGS, &dm );
if ( dm.dmPelsWidth != m_dwCreationWidth || dm.dmPelsHeight != m_dwCreationHeight )
{
int i = 0;
while( EnumDisplaySettings( NULL, i, &dm ) )
{
if ( dm.dmPelsWidth == m_dwCreationWidth && dm.dmPelsHeight == m_dwCreationHeight )
{
dm2.dmSize = sizeof(DEVMODE);
dm2.dmDriverExtra = 0;
dm2.dmPelsWidth = m_dwCreationWidth;
dm2.dmPelsHeight = m_dwCreationHeight;
dm2.dmDisplayFrequency = 75;
dm2.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
if ( ChangeDisplaySettingsEx( NULL, &dm2, NULL, CDS_TEST, NULL ) == DISP_CHANGE_SUCCESSFUL )
ChangeDisplaySettingsEx( NULL, &dm2, NULL, 0, NULL );
else
{
dm2.dmDisplayFrequency = 60;
ChangeDisplaySettingsEx( NULL, &dm2, NULL, 0, NULL );
}
m_bChangeDisplay = TRUE;
break;
}
i++;
}
}
}
RECT rc;
SetRect( &rc, 0, 0, m_dwCreationWidth, m_dwCreationHeight );
AdjustWindowRect( &rc, m_dwWindowStyle, false );
m_hWnd = CreateWindow( _T("Gate To Heavens"), m_strWindowTitle, m_dwWindowStyle,
0, 0,
(rc.right-rc.left), (rc.bottom-rc.top), 0L,
LoadMenu( hInstance, MAKEINTRESOURCE(IDR_MENU) ),
hInstance, 0L );
UpdateWindow( m_hWnd );
ShowWindow( m_hWnd , SW_SHOW );
}
if( m_hWndFocus == NULL )
m_hWndFocus = m_hWnd;
m_dwWindowStyle = GetWindowLong( m_hWnd, GWL_STYLE );
GetWindowRect( m_hWnd, &m_rcWindowBounds );
GetClientRect( m_hWnd, &m_rcWindowClient );
if( FAILED( hr = OneTimeSceneInit() ) )
{
SAFE_RELEASE( m_pD3D );
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
}
if( FAILED( hr = Initialize3DEnvironment() ) )
{
SAFE_RELEASE( m_pD3D );
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
}
m_bReady = TRUE;
return S_OK;
}
static int SortModesCallback( const VOID* arg1, const VOID* arg2 )
{
D3DDISPLAYMODE* p1 = (D3DDISPLAYMODE*)arg1;
D3DDISPLAYMODE* p2 = (D3DDISPLAYMODE*)arg2;
if( p1->Format > p2->Format ) return -1;
if( p1->Format < p2->Format ) return +1;
if( p1->Width < p2->Width ) return -1;
if( p1->Width > p2->Width ) return +1;
if( p1->Height < p2->Height ) return -1;
if( p1->Height > p2->Height ) return +1;
return 0;
}
HRESULT CD3DApplication::BuildDeviceList()
{
const DWORD dwNumDeviceTypes = 2;
const TCHAR* strDeviceDescs[] = { _T("HAL"), _T("REF") };
const D3DDEVTYPE DeviceTypes[] = { D3DDEVTYPE_HAL, D3DDEVTYPE_REF };
BOOL bHALExists = FALSE;
BOOL bHALIsWindowedCompatible = FALSE;
BOOL bHALIsDesktopCompatible = FALSE;
BOOL bHALIsSampleCompatible = FALSE;
for( UINT iAdapter = 0; iAdapter < m_pD3D->GetAdapterCount(); iAdapter++ )
{
D3DAdapterInfo* pAdapter = &m_Adapters[m_dwNumAdapters];
m_pD3D->GetAdapterIdentifier( iAdapter, D3DENUM_NO_WHQL_LEVEL, &pAdapter->d3dAdapterIdentifier );
m_pD3D->GetAdapterDisplayMode( iAdapter, &pAdapter->d3ddmDesktop );
pAdapter->dwNumDevices = 0;
pAdapter->dwCurrentDevice = 0;
D3DDISPLAYMODE modes[100];
D3DFORMAT formats[20];
DWORD dwNumFormats = 0;
DWORD dwNumModes = 0;
DWORD dwNumAdapterModes = m_pD3D->GetAdapterModeCount( iAdapter );
formats[dwNumFormats++] = pAdapter->d3ddmDesktop.Format;
for( UINT iMode = 0; iMode < dwNumAdapterModes; iMode++ )
{
D3DDISPLAYMODE DisplayMode;
m_pD3D->EnumAdapterModes( iAdapter, iMode, &DisplayMode );
if( DisplayMode.Width < 640 || DisplayMode.Height < 400 )
continue;
for( DWORD m=0L; m<dwNumModes; m++ )
{
if( ( modes[m].Width == DisplayMode.Width ) &&
( modes[m].Height == DisplayMode.Height ) &&
( modes[m].Format == DisplayMode.Format ) )
break;
}
if( m == dwNumModes )
{
modes[dwNumModes].Width = DisplayMode.Width;
modes[dwNumModes].Height = DisplayMode.Height;
modes[dwNumModes].Format = DisplayMode.Format;
modes[dwNumModes].RefreshRate = 0;
dwNumModes++;
for( DWORD f=0; f<dwNumFormats; f++ )
{
if( DisplayMode.Format == formats[f] )
break;
}
if( f== dwNumFormats )
formats[dwNumFormats++] = DisplayMode.Format;
}
}
qsort( modes, dwNumModes, sizeof(D3DDISPLAYMODE), SortModesCallback );
for( UINT iDevice = 0; iDevice < dwNumDeviceTypes; iDevice++ )
{
D3DDeviceInfo* pDevice;
pDevice = &pAdapter->devices[pAdapter->dwNumDevices];
pDevice->DeviceType = DeviceTypes[iDevice];
m_pD3D->GetDeviceCaps( iAdapter, DeviceTypes[iDevice], &pDevice->d3dCaps );
pDevice->strDesc = strDeviceDescs[iDevice];
pDevice->dwNumModes = 0;
pDevice->dwCurrentMode = 0;
pDevice->bCanDoWindowed = FALSE;
pDevice->bWindowed = FALSE;
pDevice->MultiSampleTypeFullscreen = D3DMULTISAMPLE_NONE;
pDevice->MultiSampleTypeWindowed = D3DMULTISAMPLE_NONE;
BOOL bFormatConfirmed[20];
DWORD dwBehavior[20];
D3DFORMAT fmtDepthStencil[20];
for( DWORD f=0; f<dwNumFormats; f++ )
{
bFormatConfirmed[f] = FALSE;
fmtDepthStencil[f] = D3DFMT_UNKNOWN;
if( FAILED( m_pD3D->CheckDeviceType( iAdapter, pDevice->DeviceType,
formats[f], formats[f], FALSE ) ) )
continue;
if( pDevice->DeviceType == D3DDEVTYPE_HAL )
{
bHALExists = TRUE;
if( pDevice->d3dCaps.Caps2 & D3DCAPS2_CANRENDERWINDOWED )
{
bHALIsWindowedCompatible = TRUE;
if( f == 0 )
{
bHALIsDesktopCompatible = TRUE;
}
}
}
if( pDevice->d3dCaps.DevCaps&D3DDEVCAPS_HWTRANSFORMANDLIGHT )
{
if( pDevice->d3dCaps.DevCaps&D3DDEVCAPS_PUREDEVICE )
{
dwBehavior[f] = D3DCREATE_HARDWARE_VERTEXPROCESSING |
D3DCREATE_PUREDEVICE;
if( SUCCEEDED( ConfirmDevice( &pDevice->d3dCaps, dwBehavior[f],
formats[f] ) ) )
bFormatConfirmed[f] = TRUE;
}
if ( FALSE == bFormatConfirmed[f] )
{
dwBehavior[f] = D3DCREATE_HARDWARE_VERTEXPROCESSING;
if( SUCCEEDED( ConfirmDevice( &pDevice->d3dCaps, dwBehavior[f],
formats[f] ) ) )
bFormatConfirmed[f] = TRUE;
}
if ( FALSE == bFormatConfirmed[f] )
{
dwBehavior[f] = D3DCREATE_MIXED_VERTEXPROCESSING;
if( SUCCEEDED( ConfirmDevice( &pDevice->d3dCaps, dwBehavior[f],
formats[f] ) ) )
bFormatConfirmed[f] = TRUE;
}
}
if( FALSE == bFormatConfirmed[f] )
{
dwBehavior[f] = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
if( SUCCEEDED( ConfirmDevice( &pDevice->d3dCaps, dwBehavior[f],
formats[f] ) ) )
bFormatConfirmed[f] = TRUE;
}
if( bFormatConfirmed[f] && m_bUseDepthBuffer )
{
if( !FindDepthStencilFormat( iAdapter, pDevice->DeviceType,
formats[f], &fmtDepthStencil[f] ) )
{
bFormatConfirmed[f] = FALSE;
}
}
}
for( DWORD m=0L; m<dwNumModes; m++ )
{
for( DWORD f=0; f<dwNumFormats; f++ )
{
if( modes[m].Format == formats[f] )
{
if( bFormatConfirmed[f] == TRUE )
{
pDevice->modes[pDevice->dwNumModes].Width = modes[m].Width;
pDevice->modes[pDevice->dwNumModes].Height = modes[m].Height;
pDevice->modes[pDevice->dwNumModes].Format = modes[m].Format;
pDevice->modes[pDevice->dwNumModes].dwBehavior = dwBehavior[f];
pDevice->modes[pDevice->dwNumModes].DepthStencilFormat = fmtDepthStencil[f];
pDevice->dwNumModes++;
if( pDevice->DeviceType == D3DDEVTYPE_HAL )
bHALIsSampleCompatible = TRUE;
}
}
}
}
if( !g_userConfig.isLoaded )
{
if( pDevice->d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
{
memcpy( &g_userConfig, &g_highQualityConfig, sizeof( gthconfig_t ) );
}
else
{
memcpy( &g_userConfig, &g_lowQualityConfig, sizeof( gthconfig_t ) );
}
}
for( m=0; m<pDevice->dwNumModes; m++ )
{
unsigned int width = 1024, height = 768;
if( g_userConfig.resoution == 0 )
{
width = 800;
height = 600;
}
else if( g_userConfig.resoution == 1 )
{
width = 1024;
height = 768;
}
else if( g_userConfig.resoution == 2 )
{
width = 1280;
height = 1024;
}
else if( g_userConfig.resoution == 3 )
{
width = 1600;
height = 1200;
}
if( pDevice->modes[m].Width == width && pDevice->modes[m].Height == height )
{
pDevice->dwCurrentMode = m;
if( pDevice->modes[m].Format == D3DFMT_R5G6B5 ||
pDevice->modes[m].Format == D3DFMT_X1R5G5B5 ||
pDevice->modes[m].Format == D3DFMT_A1R5G5B5 )
{
break;
}
}
}
if( bFormatConfirmed[0] && (pDevice->d3dCaps.Caps2 & D3DCAPS2_CANRENDERWINDOWED) )
{
pDevice->bCanDoWindowed = TRUE;
pDevice->bWindowed = TRUE;
}
if( pDevice->dwNumModes > 0 )
pAdapter->dwNumDevices++;
}
if( pAdapter->dwNumDevices > 0 )
m_dwNumAdapters++;
}
if( 0L == m_dwNumAdapters )
return D3DAPPERR_NOCOMPATIBLEDEVICES;
for( DWORD a=0; a<m_dwNumAdapters; a++ )
{
for( DWORD d=0; d < m_Adapters[a].dwNumDevices; d++ )
{
if( m_Adapters[a].devices[d].bWindowed )
{
m_Adapters[a].dwCurrentDevice = d;
m_dwAdapter = a;
if( m_Adapters[a].devices[d].DeviceType == D3DDEVTYPE_REF )
{
if( !bHALExists )
DisplayErrorMsg( D3DAPPERR_NOHARDWAREDEVICE, MSGWARN_SWITCHEDTOREF );
else if( !bHALIsSampleCompatible )
DisplayErrorMsg( D3DAPPERR_HALNOTCOMPATIBLE, MSGWARN_SWITCHEDTOREF );
else if( !bHALIsWindowedCompatible )
DisplayErrorMsg( D3DAPPERR_NOWINDOWEDHAL, MSGWARN_SWITCHEDTOREF );
else if( !bHALIsDesktopCompatible )
DisplayErrorMsg( D3DAPPERR_NODESKTOPHAL, MSGWARN_SWITCHEDTOREF );
else
DisplayErrorMsg( D3DAPPERR_NOHALTHISMODE, MSGWARN_SWITCHEDTOREF );
}
return S_OK;
}
}
}
return D3DAPPERR_NOWINDOWABLEDEVICES;
}
BOOL CD3DApplication::FindDepthStencilFormat( UINT iAdapter, D3DDEVTYPE DeviceType,
D3DFORMAT TargetFormat, D3DFORMAT* pDepthStencilFormat )
{
if( m_dwMinDepthBits <= 16 && m_dwMinStencilBits == 0 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D16 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D16 ) ) )
{
*pDepthStencilFormat = D3DFMT_D16;
return TRUE;
}
}
}
if( m_dwMinDepthBits <= 15 && m_dwMinStencilBits <= 1 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D15S1 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D15S1 ) ) )
{
*pDepthStencilFormat = D3DFMT_D15S1;
return TRUE;
}
}
}
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits == 0 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24X8 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D24X8 ) ) )
{
*pDepthStencilFormat = D3DFMT_D24X8;
return TRUE;
}
}
}
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits <= 8 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24S8 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D24S8 ) ) )
{
*pDepthStencilFormat = D3DFMT_D24S8;
return TRUE;
}
}
}
if( m_dwMinDepthBits <= 24 && m_dwMinStencilBits <= 4 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D24X4S4 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D24X4S4 ) ) )
{
*pDepthStencilFormat = D3DFMT_D24X4S4;
return TRUE;
}
}
}
if( m_dwMinDepthBits <= 32 && m_dwMinStencilBits == 0 )
{
if( SUCCEEDED( m_pD3D->CheckDeviceFormat( iAdapter, DeviceType,
TargetFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D32 ) ) )
{
if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( iAdapter, DeviceType,
TargetFormat, TargetFormat, D3DFMT_D32 ) ) )
{
*pDepthStencilFormat = D3DFMT_D32;
return TRUE;
}
}
}
return FALSE;
}
LRESULT CD3DApplication::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam )
{
int wmId, wmEvent;
switch( uMsg )
{
case WM_SYSCOMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch( wmId )
{
case SC_KEYMENU:
return 1;
break;
}
break;
case WM_CLOSE:
if ( GetMenu(hWnd) != NULL )
DestroyMenu( GetMenu(hWnd) );
DestroyWindow( hWnd );
PostQuitMessage(0);
return 0;
}
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
HRESULT CD3DApplication::Initialize3DEnvironment()
{
HRESULT hr;
D3DAdapterInfo* pAdapterInfo = &m_Adapters[m_dwAdapter];
D3DDeviceInfo* pDeviceInfo = &pAdapterInfo->devices[pAdapterInfo->dwCurrentDevice];
D3DModeInfo* pModeInfo = &pDeviceInfo->modes[pDeviceInfo->dwCurrentMode];
AdjustWindowForChange();
pDeviceInfo->bWindowed = m_bWindowed;
ZeroMemory( &m_d3dpp, sizeof(m_d3dpp) );
m_d3dpp.Windowed = pDeviceInfo->bWindowed;
m_d3dpp.BackBufferCount = 1;
if( pDeviceInfo->bWindowed )
m_d3dpp.MultiSampleType = pDeviceInfo->MultiSampleTypeWindowed;
else
m_d3dpp.MultiSampleType = pDeviceInfo->MultiSampleTypeFullscreen;
m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_d3dpp.EnableAutoDepthStencil = m_bUseDepthBuffer;
m_d3dpp.AutoDepthStencilFormat = pModeInfo->DepthStencilFormat;
m_d3dpp.hDeviceWindow = m_hWnd;
if( m_bWindowed )
{
m_d3dpp.BackBufferWidth = m_rcWindowClient.right - m_rcWindowClient.left;
m_d3dpp.BackBufferHeight = m_rcWindowClient.bottom - m_rcWindowClient.top;
m_d3dpp.BackBufferFormat = pAdapterInfo->d3ddmDesktop.Format;
m_d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
}
else
{
m_d3dpp.BackBufferWidth = pModeInfo->Width;
m_d3dpp.BackBufferHeight = pModeInfo->Height;
m_d3dpp.BackBufferFormat = pModeInfo->Format;
m_d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
}
if( pDeviceInfo->d3dCaps.PrimitiveMiscCaps & D3DPMISCCAPS_NULLREFERENCE )
{
DisplayErrorMsg( D3DAPPERR_NULLREFDEVICE, 0 );
}
hr = m_pD3D->CreateDevice( m_dwAdapter, pDeviceInfo->DeviceType,
m_hWndFocus, pModeInfo->dwBehavior, &m_d3dpp,
&m_pd3dDevice );
if( SUCCEEDED(hr) )
{
if( m_bWindowed )
{
if( m_bFullScreen )
{
SetWindowPos( m_hWnd, HWND_NOTOPMOST,
m_rcWindowBounds.left, m_rcWindowBounds.top,
( m_rcWindowBounds.right - m_rcWindowBounds.left ),
( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
SWP_SHOWWINDOW );
}
else
{
SetWindowPos( m_hWnd, HWND_NOTOPMOST,
m_rcWindowBounds.left, m_rcWindowBounds.top,
( m_rcWindowBounds.right - m_rcWindowBounds.left ),
( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
SWP_SHOWWINDOW );
}
}
m_pd3dDevice->GetDeviceCaps( &m_d3dCaps );
m_dwCreateFlags = pModeInfo->dwBehavior;
if( pDeviceInfo->DeviceType == D3DDEVTYPE_REF )
lstrcpy( m_strDeviceStats, TEXT("REF") );
else if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
lstrcpy( m_strDeviceStats, TEXT("HAL") );
else if( pDeviceInfo->DeviceType == D3DDEVTYPE_SW )
lstrcpy( m_strDeviceStats, TEXT("SW") );
if( pModeInfo->dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING &&
pModeInfo->dwBehavior & D3DCREATE_PUREDEVICE )
{
if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
lstrcat( m_strDeviceStats, TEXT(" (pure hw vp)") );
else
lstrcat( m_strDeviceStats, TEXT(" (simulated pure hw vp)") );
}
else if( pModeInfo->dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING )
{
if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
lstrcat( m_strDeviceStats, TEXT(" (hw vp)") );
else
lstrcat( m_strDeviceStats, TEXT(" (simulated hw vp)") );
}
else if( pModeInfo->dwBehavior & D3DCREATE_MIXED_VERTEXPROCESSING )
{
if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
lstrcat( m_strDeviceStats, TEXT(" (mixed vp)") );
else
lstrcat( m_strDeviceStats, TEXT(" (simulated mixed vp)") );
}
else if( pModeInfo->dwBehavior & D3DCREATE_SOFTWARE_VERTEXPROCESSING )
{
lstrcat( m_strDeviceStats, TEXT(" (sw vp)") );
}
if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
{
lstrcat( m_strDeviceStats, TEXT(": ") );
lstrcat( m_strDeviceStats, pAdapterInfo->d3dAdapterIdentifier.Description );
}
LPDIRECT3DSURFACE8 pBackBuffer;
m_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
pBackBuffer->GetDesc( &m_d3dsdBackBuffer );
pBackBuffer->Release();
if( m_bShowCursorWhenFullscreen && !m_bWindowed )
{
HCURSOR hCursor;
#ifdef _WIN64
hCursor = (HCURSOR)GetClassLongPtr( m_hWnd, GCLP_HCURSOR );
#else
hCursor = (HCURSOR)GetClassLong( m_hWnd, GCL_HCURSOR );
#endif
D3DUtil_SetDeviceCursor( m_pd3dDevice, hCursor, TRUE );
}
if( m_bClipCursorWhenFullscreen )
{
if (!m_bWindowed )
{
RECT rcWindow;
GetWindowRect( m_hWnd, &rcWindow );
ClipCursor( &rcWindow );
}
else
{
ClipCursor( NULL );
}
}
hr = InitDeviceObjects();
if( SUCCEEDED(hr) )
{
hr = RestoreDeviceObjects();
if( SUCCEEDED(hr) )
{
m_bActive = TRUE;
return S_OK;
}
}
InvalidateDeviceObjects();
DeleteDeviceObjects();
SAFE_RELEASE( m_pd3dDevice );
}
if( pDeviceInfo->DeviceType == D3DDEVTYPE_HAL )
{
m_dwAdapter = 0L;
pAdapterInfo = &m_Adapters[m_dwAdapter];
for( UINT i=0L; i<pAdapterInfo->dwNumDevices; i++ )
{
if( pAdapterInfo->devices[i].DeviceType == D3DDEVTYPE_REF )
{
pAdapterInfo->dwCurrentDevice = i;
pDeviceInfo = &pAdapterInfo->devices[i];
m_bWindowed = pDeviceInfo->bWindowed;
break;
}
}
if( pAdapterInfo->devices[pAdapterInfo->dwCurrentDevice].DeviceType ==
D3DDEVTYPE_REF )
{
SetWindowPos( m_hWnd, HWND_NOTOPMOST,
m_rcWindowBounds.left, m_rcWindowBounds.top,
( m_rcWindowBounds.right - m_rcWindowBounds.left ),
( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
SWP_SHOWWINDOW );
AdjustWindowForChange();
DisplayErrorMsg( hr, MSGWARN_SWITCHEDTOREF );
hr = Initialize3DEnvironment();
}
}
return hr;
}
HRESULT CD3DApplication::Resize3DEnvironment()
{
HRESULT hr;
if( FAILED( hr = InvalidateDeviceObjects() ) )
return hr;
if( FAILED( hr = m_pd3dDevice->Reset( &m_d3dpp ) ) )
return hr;
LPDIRECT3DSURFACE8 pBackBuffer;
m_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
pBackBuffer->GetDesc( &m_d3dsdBackBuffer );
pBackBuffer->Release();
if( m_bShowCursorWhenFullscreen && !m_bWindowed )
{
HCURSOR hCursor;
#ifdef _WIN64
hCursor = (HCURSOR)GetClassLongPtr( m_hWnd, GCLP_HCURSOR );
#else
hCursor = (HCURSOR)GetClassLong( m_hWnd, GCL_HCURSOR );
#endif
D3DUtil_SetDeviceCursor( m_pd3dDevice, hCursor, TRUE );
}
if( m_bClipCursorWhenFullscreen )
{
if (!m_bWindowed )
{
RECT rcWindow;
GetWindowRect( m_hWnd, &rcWindow );
ClipCursor( &rcWindow );
}
else
{
ClipCursor( NULL );
}
}
hr = RestoreDeviceObjects();
if( FAILED(hr) )
return hr;
if( FALSE == m_bFrameMoving )
{
m_bSingleStep = TRUE;
}
return S_OK;
}
HRESULT CD3DApplication::ToggleFullscreen()
{
D3DAdapterInfo* pAdapterInfo = &m_Adapters[m_dwAdapter];
D3DDeviceInfo* pDeviceInfo = &pAdapterInfo->devices[pAdapterInfo->dwCurrentDevice];
D3DModeInfo* pModeInfo = &pDeviceInfo->modes[pDeviceInfo->dwCurrentMode];
if( !m_bWindowed && !pDeviceInfo->bCanDoWindowed )
return ForceWindowed();
m_bReady = FALSE;
m_bWindowed = !m_bWindowed;
pDeviceInfo->bWindowed = m_bWindowed;
AdjustWindowForChange();
m_d3dpp.Windowed = pDeviceInfo->bWindowed;
if( m_bWindowed )
m_d3dpp.MultiSampleType = pDeviceInfo->MultiSampleTypeWindowed;
else
m_d3dpp.MultiSampleType = pDeviceInfo->MultiSampleTypeFullscreen;
m_d3dpp.AutoDepthStencilFormat = pModeInfo->DepthStencilFormat;
m_d3dpp.hDeviceWindow = m_hWnd;
if( m_bWindowed )
{
m_d3dpp.BackBufferWidth = 1024;
m_d3dpp.BackBufferHeight = 768;
m_d3dpp.BackBufferFormat = pAdapterInfo->d3ddmDesktop.Format;
}
else
{
m_d3dpp.BackBufferWidth = pModeInfo->Width;
m_d3dpp.BackBufferHeight = pModeInfo->Height;
m_d3dpp.BackBufferFormat = pModeInfo->Format;
}
if( FAILED( Resize3DEnvironment() ) )
{
if( m_bWindowed )
return ForceWindowed();
else
return E_FAIL;
}
if( m_bWindowed )
{
if( m_bFullScreen )
{
SetWindowPos( m_hWnd, HWND_NOTOPMOST,
m_rcWindowBounds.left, m_rcWindowBounds.top,
800,
600,
SWP_SHOWWINDOW );
}
else
{
SetWindowPos( m_hWnd, HWND_NOTOPMOST,
m_rcWindowBounds.left, m_rcWindowBounds.top,
800,
600,
SWP_SHOWWINDOW );
}
}
m_bReady = TRUE;
return S_OK;
}
HRESULT CD3DApplication::ForceWindowed()
{
HRESULT hr;
D3DAdapterInfo* pAdapterInfoCur = &m_Adapters[m_dwAdapter];
D3DDeviceInfo* pDeviceInfoCur = &pAdapterInfoCur->devices[pAdapterInfoCur->dwCurrentDevice];
BOOL bFoundDevice = FALSE;
if( pDeviceInfoCur->bCanDoWindowed )
{
bFoundDevice = TRUE;
}
else
{
D3DAdapterInfo* pAdapterInfo;
DWORD dwAdapter;
D3DDeviceInfo* pDeviceInfo;
DWORD dwDevice;
for( dwAdapter = 0; dwAdapter < m_dwNumAdapters; dwAdapter++ )
{
pAdapterInfo = &m_Adapters[dwAdapter];
for( dwDevice = 0; dwDevice < pAdapterInfo->dwNumDevices; dwDevice++ )
{
pDeviceInfo = &pAdapterInfo->devices[dwDevice];
if( pDeviceInfo->bCanDoWindowed )
{
m_dwAdapter = dwAdapter;
pDeviceInfoCur = pDeviceInfo;
pAdapterInfo->dwCurrentDevice = dwDevice;
bFoundDevice = TRUE;
break;
}
}
if( bFoundDevice )
break;
}
}
if( !bFoundDevice )
return E_FAIL;
pDeviceInfoCur->bWindowed = TRUE;
m_bWindowed = TRUE;
m_bReady = FALSE;
InvalidateDeviceObjects();
DeleteDeviceObjects();
if( m_pd3dDevice->Release() > 0L )
return DisplayErrorMsg( D3DAPPERR_NONZEROREFCOUNT, MSGERR_APPMUSTEXIT );
if( FAILED( hr = Initialize3DEnvironment() ) )
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
m_bReady = TRUE;
return S_OK;
}
HRESULT CD3DApplication::AdjustWindowForChange()
{
if( m_bWindowed )
{
SetWindowLong( m_hWnd, GWL_STYLE, m_dwWindowStyle );
}
else
{
SetWindowLong( m_hWnd, GWL_STYLE, WS_POPUP|WS_SYSMENU|WS_VISIBLE );
}
return S_OK;
}
HRESULT CD3DApplication::UserSelectNewDevice()
{
HRESULT hr;
if( m_bWindowed == FALSE )
{
if( FAILED( ToggleFullscreen() ) )
{
DisplayErrorMsg( D3DAPPERR_RESIZEFAILED, MSGERR_APPMUSTEXIT );
return E_FAIL;
}
}
if( IDOK != DialogBoxParam( (HINSTANCE)GetModuleHandle(NULL),
MAKEINTRESOURCE(IDD_SELECTDEVICE), m_hWnd,
SelectDeviceProc, (LPARAM)this ) )
return S_OK;
DWORD dwDevice;
dwDevice = m_Adapters[m_dwAdapter].dwCurrentDevice;
m_bWindowed = m_Adapters[m_dwAdapter].devices[dwDevice].bWindowed;
InvalidateDeviceObjects();
DeleteDeviceObjects();
if( m_pd3dDevice->Release() > 0L )
return DisplayErrorMsg( D3DAPPERR_NONZEROREFCOUNT, MSGERR_APPMUSTEXIT );
if( FAILED( hr = Initialize3DEnvironment() ) )
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
if( FALSE == m_bFrameMoving )
{
m_bSingleStep = TRUE;
}
return S_OK;
}
INT_PTR CALLBACK CD3DApplication::SelectDeviceProc( HWND hDlg, UINT msg,
WPARAM wParam, LPARAM lParam )
{
HWND hwndAdapterList = GetDlgItem( hDlg, IDC_ADAPTER_COMBO );
HWND hwndDeviceList = GetDlgItem( hDlg, IDC_DEVICE_COMBO );
HWND hwndFullscreenModeList = GetDlgItem( hDlg, IDC_FULLSCREENMODES_COMBO );
HWND hwndWindowedRadio = GetDlgItem( hDlg, IDC_WINDOW );
HWND hwndFullscreenRadio = GetDlgItem( hDlg, IDC_FULLSCREEN );
HWND hwndMultiSampleList = GetDlgItem( hDlg, IDC_MULTISAMPLE_COMBO );
BOOL bUpdateDlgControls = FALSE;
static CD3DApplication* pd3dApp;
static DWORD dwOldAdapter, dwNewAdapter;
static DWORD dwOldDevice, dwNewDevice;
static DWORD dwOldMode, dwNewMode;
static BOOL bOldWindowed, bNewWindowed;
static D3DMULTISAMPLE_TYPE OldMultiSampleTypeWindowed, NewMultiSampleTypeWindowed;
static D3DMULTISAMPLE_TYPE OldMultiSampleTypeFullscreen, NewMultiSampleTypeFullscreen;
D3DAdapterInfo* pAdapter;
D3DDeviceInfo* pDevice;
if( WM_INITDIALOG == msg )
{
pd3dApp = (CD3DApplication*)lParam;
dwOldAdapter = pd3dApp->m_dwAdapter;
pAdapter = &pd3dApp->m_Adapters[dwOldAdapter];
dwOldDevice = pAdapter->dwCurrentDevice;
pDevice = &pAdapter->devices[dwOldDevice];
dwOldMode = pDevice->dwCurrentMode;
bOldWindowed = pDevice->bWindowed;
OldMultiSampleTypeWindowed = pDevice->MultiSampleTypeWindowed;
OldMultiSampleTypeFullscreen = pDevice->MultiSampleTypeFullscreen;
dwNewAdapter = dwOldAdapter;
dwNewDevice = dwOldDevice;
dwNewMode = dwOldMode;
bNewWindowed = bOldWindowed;
NewMultiSampleTypeWindowed = OldMultiSampleTypeWindowed;
NewMultiSampleTypeFullscreen = OldMultiSampleTypeFullscreen;
bUpdateDlgControls = TRUE;
}
if( WM_COMMAND == msg )
{
bNewWindowed = Button_GetCheck( hwndWindowedRadio );
if( IDOK == LOWORD(wParam) )
{
if( dwNewAdapter != dwOldAdapter || dwNewDevice != dwOldDevice ||
dwNewMode != dwOldMode || bNewWindowed != bOldWindowed ||
NewMultiSampleTypeWindowed != OldMultiSampleTypeWindowed ||
NewMultiSampleTypeFullscreen != OldMultiSampleTypeFullscreen )
{
pd3dApp->m_dwAdapter = dwNewAdapter;
pAdapter = &pd3dApp->m_Adapters[dwNewAdapter];
pAdapter->dwCurrentDevice = dwNewDevice;
pAdapter->devices[dwNewDevice].dwCurrentMode = dwNewMode;
pAdapter->devices[dwNewDevice].bWindowed = bNewWindowed;
pAdapter->devices[dwNewDevice].MultiSampleTypeWindowed = NewMultiSampleTypeWindowed;
pAdapter->devices[dwNewDevice].MultiSampleTypeFullscreen = NewMultiSampleTypeFullscreen;
EndDialog( hDlg, IDOK );
}
else
EndDialog( hDlg, IDCANCEL );
return TRUE;
}
else if( IDCANCEL == LOWORD(wParam) )
{
EndDialog( hDlg, IDCANCEL );
return TRUE;
}
else if( CBN_SELENDOK == HIWORD(wParam) )
{
if( LOWORD(wParam) == IDC_ADAPTER_COMBO )
{
dwNewAdapter = ComboBox_GetCurSel( hwndAdapterList );
pAdapter = &pd3dApp->m_Adapters[dwNewAdapter];
dwNewDevice = pAdapter->dwCurrentDevice;
dwNewMode = pAdapter->devices[dwNewDevice].dwCurrentMode;
bNewWindowed = pAdapter->devices[dwNewDevice].bWindowed;
}
else if( LOWORD(wParam) == IDC_DEVICE_COMBO )
{
pAdapter = &pd3dApp->m_Adapters[dwNewAdapter];
dwNewDevice = ComboBox_GetCurSel( hwndDeviceList );
dwNewMode = pAdapter->devices[dwNewDevice].dwCurrentMode;
bNewWindowed = pAdapter->devices[dwNewDevice].bWindowed;
}
else if( LOWORD(wParam) == IDC_FULLSCREENMODES_COMBO )
{
dwNewMode = ComboBox_GetCurSel( hwndFullscreenModeList );
}
else if( LOWORD(wParam) == IDC_MULTISAMPLE_COMBO )
{
DWORD dwItem = ComboBox_GetCurSel( hwndMultiSampleList );
if( bNewWindowed )
NewMultiSampleTypeWindowed = (D3DMULTISAMPLE_TYPE)ComboBox_GetItemData( hwndMultiSampleList, dwItem );
else
NewMultiSampleTypeFullscreen = (D3DMULTISAMPLE_TYPE)ComboBox_GetItemData( hwndMultiSampleList, dwItem );
}
}
bUpdateDlgControls = TRUE;
}
if( bUpdateDlgControls )
{
ComboBox_ResetContent( hwndAdapterList );
ComboBox_ResetContent( hwndDeviceList );
ComboBox_ResetContent( hwndFullscreenModeList );
ComboBox_ResetContent( hwndMultiSampleList );
pAdapter = &pd3dApp->m_Adapters[dwNewAdapter];
pDevice = &pAdapter->devices[dwNewDevice];
for( DWORD a=0; a < pd3dApp->m_dwNumAdapters; a++ )
{
DWORD dwItem = ComboBox_AddString( hwndAdapterList,
pd3dApp->m_Adapters[a].d3dAdapterIdentifier.Description );
ComboBox_SetItemData( hwndAdapterList, dwItem, a );
if( a == dwNewAdapter )
ComboBox_SetCurSel( hwndAdapterList, dwItem );
}
for( DWORD d=0; d < pAdapter->dwNumDevices; d++ )
{
DWORD dwItem = ComboBox_AddString( hwndDeviceList,
pAdapter->devices[d].strDesc );
ComboBox_SetItemData( hwndDeviceList, dwItem, d );
if( d == dwNewDevice )
ComboBox_SetCurSel( hwndDeviceList, dwItem );
}
for( DWORD m=0; m < pDevice->dwNumModes; m++ )
{
DWORD BitDepth = 16;
if( pDevice->modes[m].Format == D3DFMT_X8R8G8B8 ||
pDevice->modes[m].Format == D3DFMT_A8R8G8B8 ||
pDevice->modes[m].Format == D3DFMT_R8G8B8 )
{
BitDepth = 32;
}
TCHAR strMode[80];
_stprintf( strMode, _T("%ld x %ld x %ld"), pDevice->modes[m].Width,
pDevice->modes[m].Height,
BitDepth );
DWORD dwItem = ComboBox_AddString( hwndFullscreenModeList, strMode );
ComboBox_SetItemData( hwndFullscreenModeList, dwItem, m );
if( m == dwNewMode )
ComboBox_SetCurSel( hwndFullscreenModeList, dwItem );
}
for( m=0; m <= 16; m++ )
{
TCHAR strDesc[50];
D3DFORMAT fmt;
if( bNewWindowed )
fmt = pd3dApp->m_Adapters[dwNewAdapter].d3ddmDesktop.Format;
else
fmt = pDevice->modes[dwNewMode].Format;
if ( m == 1 )
continue;
if( SUCCEEDED( pd3dApp->m_pD3D->CheckDeviceMultiSampleType( dwNewAdapter,
pDevice->DeviceType, fmt, bNewWindowed, (D3DMULTISAMPLE_TYPE)m ) ) )
{
if( m == 0 )
lstrcpy( strDesc, _T("none") );
else
wsprintf( strDesc, _T("%d samples"), m );
DWORD dwItem = ComboBox_AddString( hwndMultiSampleList, strDesc );
ComboBox_SetItemData( hwndMultiSampleList, dwItem, m );
if( bNewWindowed )
{
if( (D3DMULTISAMPLE_TYPE)m == NewMultiSampleTypeWindowed || m == 0 )
ComboBox_SetCurSel( hwndMultiSampleList, dwItem );
}
else
{
if( (D3DMULTISAMPLE_TYPE)m == NewMultiSampleTypeFullscreen || m == 0 )
ComboBox_SetCurSel( hwndMultiSampleList, dwItem );
}
}
}
DWORD dwItem = ComboBox_GetCurSel( hwndMultiSampleList );
if( bNewWindowed )
NewMultiSampleTypeWindowed = (D3DMULTISAMPLE_TYPE)ComboBox_GetItemData( hwndMultiSampleList, dwItem );
else
NewMultiSampleTypeFullscreen = (D3DMULTISAMPLE_TYPE)ComboBox_GetItemData( hwndMultiSampleList, dwItem );
EnableWindow( hwndMultiSampleList, ComboBox_GetCount( hwndMultiSampleList ) > 1);
EnableWindow( hwndWindowedRadio, pDevice->bCanDoWindowed );
if( bNewWindowed )
{
Button_SetCheck( hwndWindowedRadio, TRUE );
Button_SetCheck( hwndFullscreenRadio, FALSE );
EnableWindow( hwndFullscreenModeList, FALSE );
}
else
{
Button_SetCheck( hwndWindowedRadio, FALSE );
Button_SetCheck( hwndFullscreenRadio, TRUE );
EnableWindow( hwndFullscreenModeList, TRUE );
}
return TRUE;
}
return FALSE;
}
INT CD3DApplication::Run()
{
HACCEL hAccel = LoadAccelerators( NULL, MAKEINTRESOURCE(IDR_MAIN_ACCEL) );
BOOL bGotMsg;
MSG msg;
msg.message = WM_NULL;
PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE );
while( WM_QUIT != msg.message && !m_bAppExit )
{
if( m_bActive )
bGotMsg = PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE );
else
bGotMsg = GetMessage( &msg, NULL, 0U, 0U );
if( bGotMsg )
{
if( 0 == TranslateAccelerator( m_hWnd, hAccel, &msg ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
else
{
if( m_bActive && m_bReady )
{
if( FAILED( Render3DEnvironment() ) )
SendMessage( m_hWnd, WM_CLOSE, 0, 0 );
}
}
}
Cleanup3DEnvironment();
return (INT)msg.wParam;
}
HRESULT CD3DApplication::Render3DEnvironment()
{
HRESULT hr;
if( FAILED( hr = m_pd3dDevice->TestCooperativeLevel() ) )
{
if( D3DERR_DEVICELOST == hr )
return S_OK;
if( D3DERR_DEVICENOTRESET == hr )
{
if( m_bWindowed )
{
D3DAdapterInfo* pAdapterInfo = &m_Adapters[m_dwAdapter];
m_pD3D->GetAdapterDisplayMode( m_dwAdapter, &pAdapterInfo->d3ddmDesktop );
m_d3dpp.BackBufferFormat = pAdapterInfo->d3ddmDesktop.Format;
}
if( FAILED( hr = Resize3DEnvironment() ) )
return hr;
}
return hr;
}
FLOAT fAppTime = DXUtil_Timer( TIMER_GETAPPTIME );
FLOAT fElapsedAppTime = DXUtil_Timer( TIMER_GETELAPSEDTIME );
if( ( 0.0f == fElapsedAppTime ) && m_bFrameMoving )
return S_OK;
if( m_bFrameMoving || m_bSingleStep )
{
m_fTime = fAppTime;
m_fElapsedTime = fElapsedAppTime;
if( FAILED( hr = FrameMove() ) )
return hr;
m_bSingleStep = FALSE;
}
if( FAILED( hr = Render() ) )
return hr;
{
static FLOAT fLastTime = 0.0f;
static DWORD dwFrames = 0L;
FLOAT fTime = DXUtil_Timer( TIMER_GETABSOLUTETIME );
++dwFrames;
if( fTime - fLastTime > 1.0f )
{
m_fFPS = dwFrames / (fTime - fLastTime);
fLastTime = fTime;
dwFrames = 0L;
D3DDISPLAYMODE mode;
m_pD3D->GetAdapterDisplayMode(m_dwAdapter, &mode);
_stprintf( m_strFrameStats, _T("%.02f fps (%dx%dx%d)"), m_fFPS,
m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height,
mode.Format==D3DFMT_X8R8G8B8?32:16 );
D3DAdapterInfo* pAdapterInfo = &m_Adapters[m_dwAdapter];
D3DDeviceInfo* pDeviceInfo = &pAdapterInfo->devices[pAdapterInfo->dwCurrentDevice];
D3DModeInfo* pModeInfo = &pDeviceInfo->modes[pDeviceInfo->dwCurrentMode];
if( m_bUseDepthBuffer )
{
switch( pModeInfo->DepthStencilFormat )
{
case D3DFMT_D16:
lstrcat( m_strFrameStats, _T(" (D16)") );
break;
case D3DFMT_D15S1:
lstrcat( m_strFrameStats, _T(" (D15S1)") );
break;
case D3DFMT_D24X8:
lstrcat( m_strFrameStats, _T(" (D24X8)") );
break;
case D3DFMT_D24S8:
lstrcat( m_strFrameStats, _T(" (D24S8)") );
break;
case D3DFMT_D24X4S4:
lstrcat( m_strFrameStats, _T(" (D24X4S4)") );
break;
case D3DFMT_D32:
lstrcat( m_strFrameStats, _T(" (D32)") );
break;
}
}
D3DMULTISAMPLE_TYPE MultiSampleType;
if( m_bWindowed )
MultiSampleType = pDeviceInfo->MultiSampleTypeWindowed;
else
MultiSampleType = pDeviceInfo->MultiSampleTypeFullscreen;
switch( MultiSampleType )
{
case D3DMULTISAMPLE_2_SAMPLES:
lstrcat( m_strFrameStats, _T(" (2x Multisample)") );
break;
case D3DMULTISAMPLE_3_SAMPLES:
lstrcat( m_strFrameStats, _T(" (3x Multisample)") );
break;
case D3DMULTISAMPLE_4_SAMPLES:
lstrcat( m_strFrameStats, _T(" (4x Multisample)") );
break;
case D3DMULTISAMPLE_5_SAMPLES:
lstrcat( m_strFrameStats, _T(" (5x Multisample)") );
break;
case D3DMULTISAMPLE_6_SAMPLES:
lstrcat( m_strFrameStats, _T(" (6x Multisample)") );
break;
case D3DMULTISAMPLE_7_SAMPLES:
lstrcat( m_strFrameStats, _T(" (7x Multisample)") );
break;
case D3DMULTISAMPLE_8_SAMPLES:
lstrcat( m_strFrameStats, _T(" (8x Multisample)") );
break;
case D3DMULTISAMPLE_9_SAMPLES:
lstrcat( m_strFrameStats, _T(" (9x Multisample)") );
break;
case D3DMULTISAMPLE_10_SAMPLES:
lstrcat( m_strFrameStats, _T(" (10x Multisample)") );
break;
case D3DMULTISAMPLE_11_SAMPLES:
lstrcat( m_strFrameStats, _T(" (11x Multisample)") );
break;
case D3DMULTISAMPLE_12_SAMPLES:
lstrcat( m_strFrameStats, _T(" (12x Multisample)") );
break;
case D3DMULTISAMPLE_13_SAMPLES:
lstrcat( m_strFrameStats, _T(" (13x Multisample)") );
break;
case D3DMULTISAMPLE_14_SAMPLES:
lstrcat( m_strFrameStats, _T(" (14x Multisample)") );
break;
case D3DMULTISAMPLE_15_SAMPLES:
lstrcat( m_strFrameStats, _T(" (15x Multisample)") );
break;
case D3DMULTISAMPLE_16_SAMPLES:
lstrcat( m_strFrameStats, _T(" (16x Multisample)") );
break;
}
}
}
m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
return S_OK;
}
VOID CD3DApplication::Pause( BOOL bPause )
{
static DWORD dwAppPausedCount = 0L;
dwAppPausedCount += ( bPause ? +1 : -1 );
m_bReady = ( dwAppPausedCount ? FALSE : TRUE );
if( bPause && ( 1 == dwAppPausedCount ) )
{
}
if( 0 == dwAppPausedCount )
{
}
}
VOID CD3DApplication::Cleanup3DEnvironment()
{
m_bActive = FALSE;
m_bReady = FALSE;
if( m_pd3dDevice )
{
InvalidateDeviceObjects();
DeleteDeviceObjects();
m_pd3dDevice->Release();
m_pD3D->Release();
m_pd3dDevice = NULL;
m_pD3D = NULL;
}
FinalCleanup();
}
HRESULT CD3DApplication::DisplayErrorMsg( HRESULT hr, DWORD dwType )
{
TCHAR strMsg[512];
switch( hr )
{
case D3DAPPERR_NODIRECT3D:
_tcscpy( strMsg, _T("Could not initialize Direct3D. You may\n")
_T("want to check that the latest version of\n")
_T("DirectX is correctly installed on your\n")
_T("system. Also make sure that this program\n")
_T("was compiled with header files that match\n")
_T("the installed DirectX DLLs.") );
break;
case D3DAPPERR_NOCOMPATIBLEDEVICES:
_tcscpy( strMsg, _T("Could not find any compatible Direct3D\n")
_T("devices.") );
break;
case D3DAPPERR_NOWINDOWABLEDEVICES:
_tcscpy( strMsg, _T("This sample cannot run in a desktop\n")
_T("window with the current display settings.\n")
_T("Please change your desktop settings to a\n")
_T("16- or 32-bit display mode and re-run this\n")
_T("sample.") );
break;
case D3DAPPERR_NOHARDWAREDEVICE:
_tcscpy( strMsg, _T("No hardware-accelerated Direct3D devices\n")
_T("were found.") );
break;
case D3DAPPERR_HALNOTCOMPATIBLE:
_tcscpy( strMsg, _T("This sample requires functionality that is\n")
_T("not available on your Direct3D hardware\n")
_T("accelerator.") );
break;
case D3DAPPERR_NOWINDOWEDHAL:
_tcscpy( strMsg, _T("Your Direct3D hardware accelerator cannot\n")
_T("render into a window.\n")
_T("Press F2 while the app is running to see a\n")
_T("list of available devices and modes.") );
break;
case D3DAPPERR_NODESKTOPHAL:
_tcscpy( strMsg, _T("Your Direct3D hardware accelerator cannot\n")
_T("render into a window with the current\n")
_T("desktop display settings.\n")
_T("Press F2 while the app is running to see a\n")
_T("list of available devices and modes.") );
break;
case D3DAPPERR_NOHALTHISMODE:
_tcscpy( strMsg, _T("This sample requires functionality that is\n")
_T("not available on your Direct3D hardware\n")
_T("accelerator with the current desktop display\n")
_T("settings.\n")
_T("Press F2 while the app is running to see a\n")
_T("list of available devices and modes.") );
break;
case D3DAPPERR_MEDIANOTFOUND:
_tcscpy( strMsg, _T("Could not load required media." ) );
break;
case D3DAPPERR_RESIZEFAILED:
_tcscpy( strMsg, _T("Could not reset the Direct3D device." ) );
break;
case D3DAPPERR_NONZEROREFCOUNT:
_tcscpy( strMsg, _T("A D3D object has a non-zero reference\n")
_T("count (meaning things were not properly\n")
_T("cleaned up).") );
break;
case D3DAPPERR_NULLREFDEVICE:
_tcscpy( strMsg, _T("Warning: Nothing will be rendered.\n")
_T("The reference rendering device was selected, but your\n")
_T("computer only has a reduced-functionality reference device\n")
_T("installed. Install the DirectX SDK to get the full\n")
_T("reference device.\n") );
break;
case E_OUTOFMEMORY:
_tcscpy( strMsg, _T("Not enough memory.") );
break;
case D3DERR_OUTOFVIDEOMEMORY:
_tcscpy( strMsg, _T("Not enough video memory.") );
break;
default:
_tcscpy( strMsg, _T("Generic application error. Enable\n")
_T("debug output for detailed information.") );
}
if( MSGERR_APPMUSTEXIT == dwType )
{
_tcscat( strMsg, _T("\n\nThis sample will now exit.") );
MessageBox( NULL, strMsg, m_strWindowTitle, MB_ICONERROR|MB_OK );
if( m_hWnd )
SendMessage( m_hWnd, WM_CLOSE, 0, 0 );
}
else
{
if( MSGWARN_SWITCHEDTOREF == dwType )
_tcscat( strMsg, _T("\n\nSwitching to the reference rasterizer,\n")
_T("a software device that implements the entire\n")
_T("Direct3D feature set, but runs very slowly.") );
MessageBox( NULL, strMsg, m_strWindowTitle, MB_ICONWARNING|MB_OK );
}
return hr;
}
| C++ |
#ifndef D3DAPP_H
#define D3DAPP_H
#include <basetsd.h>
enum APPMSGTYPE { MSG_NONE, MSGERR_APPMUSTEXIT, MSGWARN_SWITCHEDTOREF };
#define D3DAPPERR_NODIRECT3D 0x82000001
#define D3DAPPERR_NOWINDOW 0x82000002
#define D3DAPPERR_NOCOMPATIBLEDEVICES 0x82000003
#define D3DAPPERR_NOWINDOWABLEDEVICES 0x82000004
#define D3DAPPERR_NOHARDWAREDEVICE 0x82000005
#define D3DAPPERR_HALNOTCOMPATIBLE 0x82000006
#define D3DAPPERR_NOWINDOWEDHAL 0x82000007
#define D3DAPPERR_NODESKTOPHAL 0x82000008
#define D3DAPPERR_NOHALTHISMODE 0x82000009
#define D3DAPPERR_NONZEROREFCOUNT 0x8200000a
#define D3DAPPERR_MEDIANOTFOUND 0x8200000b
#define D3DAPPERR_RESIZEFAILED 0x8200000c
#define D3DAPPERR_NULLREFDEVICE 0x8200000d
#define MAX_CANDLIST 10
#define MAX_COMPSTRING_SIZE 256
struct D3DModeInfo
{
DWORD Width;
DWORD Height;
D3DFORMAT Format;
DWORD dwBehavior;
D3DFORMAT DepthStencilFormat;
};
struct D3DDeviceInfo
{
D3DDEVTYPE DeviceType;
D3DCAPS8 d3dCaps;
const TCHAR* strDesc;
BOOL bCanDoWindowed;
DWORD dwNumModes;
D3DModeInfo modes[150];
DWORD dwCurrentMode;
BOOL bWindowed;
D3DMULTISAMPLE_TYPE MultiSampleTypeWindowed;
D3DMULTISAMPLE_TYPE MultiSampleTypeFullscreen;
};
struct D3DAdapterInfo
{
D3DADAPTER_IDENTIFIER8 d3dAdapterIdentifier;
D3DDISPLAYMODE d3ddmDesktop;
DWORD dwNumDevices;
D3DDeviceInfo devices[5];
DWORD dwCurrentDevice;
};
class CD3DApplication
{
protected:
D3DAdapterInfo m_Adapters[10];
DWORD m_dwNumAdapters;
DWORD m_dwAdapter;
BOOL m_bWindowed;
BOOL m_bActive;
BOOL m_bReady;
BOOL m_bHasFocus;
BOOL m_bFrameMoving;
BOOL m_bSingleStep;
HRESULT DisplayErrorMsg( HRESULT hr, DWORD dwType );
HRESULT BuildDeviceList();
BOOL FindDepthStencilFormat( UINT iAdapter, D3DDEVTYPE DeviceType,
D3DFORMAT TargetFormat, D3DFORMAT* pDepthStencilFormat );
HRESULT Initialize3DEnvironment();
HRESULT Resize3DEnvironment();
HRESULT ToggleFullscreen();
HRESULT ForceWindowed();
HRESULT UserSelectNewDevice();
VOID Cleanup3DEnvironment();
HRESULT Render3DEnvironment();
virtual HRESULT AdjustWindowForChange();
static INT_PTR CALLBACK SelectDeviceProc( HWND hDlg, UINT msg,
WPARAM wParam, LPARAM lParam );
protected:
D3DPRESENT_PARAMETERS m_d3dpp;
HWND m_hWndFocus;
LPDIRECT3D8 m_pD3D;
LPDIRECT3DDEVICE8 m_pd3dDevice;
D3DCAPS8 m_d3dCaps;
D3DSURFACE_DESC m_d3dsdBackBuffer;
DWORD m_dwCreateFlags;
DWORD m_dwWindowStyle;
RECT m_rcWindowBounds;
RECT m_rcWindowClient;
FLOAT m_fTime;
FLOAT m_fElapsedTime;
FLOAT m_fFPS;
TCHAR m_strDeviceStats[90];
TCHAR m_strFrameStats[90];
TCHAR* m_strWindowTitle;
BOOL m_bUseDepthBuffer;
DWORD m_dwMinDepthBits;
DWORD m_dwMinStencilBits;
DWORD m_dwCreationWidth;
DWORD m_dwCreationHeight;
BOOL m_bShowCursorWhenFullscreen;
BOOL m_bClipCursorWhenFullscreen;
virtual HRESULT ConfirmDevice(D3DCAPS8*,DWORD,D3DFORMAT) { return S_OK; }
virtual HRESULT OneTimeSceneInit() { return S_OK; }
virtual HRESULT InitDeviceObjects() { return S_OK; }
virtual HRESULT RestoreDeviceObjects() { return S_OK; }
virtual HRESULT FrameMove() { return S_OK; }
virtual HRESULT Render() { return S_OK; }
virtual HRESULT InvalidateDeviceObjects() { return S_OK; }
virtual HRESULT DeleteDeviceObjects() { return S_OK; }
virtual HRESULT FinalCleanup() { return S_OK; }
public:
HWND m_hWnd;
BOOL m_bAppExit;
BOOL m_bChangeDisplay;
bool m_bFullScreen;
D3DGAMMARAMP m_ramp;
virtual HRESULT Create( HINSTANCE hInstance );
virtual INT Run();
virtual LRESULT MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
virtual VOID Pause( BOOL bPause );
void SetWindowMode( BOOL bWindow ) { m_bWindowed = bWindow; }
BOOL GetWindowMode() { return( m_bWindowed ); }
CD3DApplication();
};
#endif
| C++ |
#ifndef D3DUTIL_H
#define D3DUTIL_H
#include <D3D8.h>
#include <D3DX8Math.h>
VOID D3DUtil_InitMaterial( D3DMATERIAL8& mtrl, FLOAT r=0.0f, FLOAT g=0.0f,
FLOAT b=0.0f, FLOAT a=1.0f );
VOID D3DUtil_InitLight( D3DLIGHT8& light, D3DLIGHTTYPE ltType,
FLOAT x=0.0f, FLOAT y=0.0f, FLOAT z=0.0f );
HRESULT D3DUtil_CreateTexture( LPDIRECT3DDEVICE8 pd3dDevice, TCHAR* strTexture,
LPDIRECT3DTEXTURE8* ppTexture,
D3DFORMAT d3dFormat = D3DFMT_UNKNOWN );
HRESULT D3DUtil_SetColorKey( LPDIRECT3DTEXTURE8 pTexture, DWORD dwColorKey );
HRESULT D3DUtil_CreateVertexShader( LPDIRECT3DDEVICE8 pd3dDevice,
TCHAR* strFilename, DWORD* pdwVertexDecl,
DWORD* pdwVertexShader );
D3DXMATRIX D3DUtil_GetCubeMapViewMatrix( DWORD dwFace );
D3DXQUATERNION D3DUtil_GetRotationFromCursor( HWND hWnd,
FLOAT fTrackBallRadius=1.0f );
HRESULT D3DUtil_SetDeviceCursor( LPDIRECT3DDEVICE8 pd3dDevice, HCURSOR hCursor,
BOOL bAddWatermark );
class CD3DArcBall
{
INT m_iWidth;
INT m_iHeight;
FLOAT m_fRadius;
FLOAT m_fRadiusTranslation;
D3DXQUATERNION m_qDown;
D3DXQUATERNION m_qNow;
D3DXMATRIX m_matRotation;
D3DXMATRIX m_matRotationDelta;
D3DXMATRIX m_matTranslation;
D3DXMATRIX m_matTranslationDelta;
BOOL m_bDrag;
BOOL m_bRightHanded;
D3DXVECTOR3 ScreenToVector( int sx, int sy );
public:
LRESULT HandleMouseMessages( HWND, UINT, WPARAM, LPARAM );
D3DXMATRIX* GetRotationMatrix() { return &m_matRotation; }
D3DXMATRIX* GetRotationDeltaMatrix() { return &m_matRotationDelta; }
D3DXMATRIX* GetTranslationMatrix() { return &m_matTranslation; }
D3DXMATRIX* GetTranslationDeltaMatrix() { return &m_matTranslationDelta; }
BOOL IsBeingDragged() { return m_bDrag; }
VOID SetRadius( FLOAT fRadius );
VOID SetWindow( INT w, INT h, FLOAT r=0.9 );
VOID SetRightHanded( BOOL bRightHanded ) { m_bRightHanded = bRightHanded; }
CD3DArcBall();
};
class CD3DCamera
{
D3DXVECTOR3 m_vEyePt;
D3DXVECTOR3 m_vLookatPt;
D3DXVECTOR3 m_vUpVec;
D3DXVECTOR3 m_vView;
D3DXVECTOR3 m_vCross;
D3DXMATRIX m_matView;
D3DXMATRIX m_matBillboard;
FLOAT m_fFOV;
FLOAT m_fAspect;
FLOAT m_fNearPlane;
FLOAT m_fFarPlane;
D3DXMATRIX m_matProj;
public:
D3DXVECTOR3 GetEyePt() { return m_vEyePt; }
D3DXVECTOR3 GetLookatPt() { return m_vLookatPt; }
D3DXVECTOR3 GetUpVec() { return m_vUpVec; }
D3DXVECTOR3 GetViewDir() { return m_vView; }
D3DXVECTOR3 GetCross() { return m_vCross; }
D3DXMATRIX GetViewMatrix() { return m_matView; }
D3DXMATRIX GetBillboardMatrix() { return m_matBillboard; }
D3DXMATRIX GetProjMatrix() { return m_matProj; }
VOID SetViewParams( D3DXVECTOR3 &vEyePt, D3DXVECTOR3& vLookatPt,
D3DXVECTOR3& vUpVec );
VOID SetProjParams( FLOAT fFOV, FLOAT fAspect, FLOAT fNearPlane,
FLOAT fFarPlane );
CD3DCamera();
};
#define D3DPSP_WRITEMASK_B D3DSP_WRITEMASK_0
#define D3DPSP_WRITEMASK_G D3DSP_WRITEMASK_1
#define D3DPSP_WRITEMASK_R D3DSP_WRITEMASK_2
#define D3DPSP_WRITEMASK_A D3DSP_WRITEMASK_3
#define D3DPSP_WRITEMASK_C (D3DPSP_WRITEMASK_B|D3DPSP_WRITEMASK_G|D3DPSP_WRITEMASK_R)
#define D3DPSP_WRITEMASK_ALL (D3DSP_WRITEMASK_0|D3DSP_WRITEMASK_1|D3DSP_WRITEMASK_2|D3DSP_WRITEMASK_3)
#define D3DPSP_WRITEMASK_10 (D3DSP_WRITEMASK_0|D3DSP_WRITEMASK_1)
#define D3DPSP_WRITEMASK_32 (D3DSP_WRITEMASK_2|D3DSP_WRITEMASK_3)
#define D3DPS_REGNUM_MASK(_Num) ( (1L<<31) | ((_Num)&D3DSP_REGNUM_MASK) )
#define D3DPS_DST(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSPR_TEMP | D3DPSP_WRITEMASK_ALL )
#define D3DPS_SRC_TEMP(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_TEMP )
#define D3DPS_SRC_INPUT(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_INPUT )
#define D3DPS_SRC_CONST(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_CONST )
#define D3DPS_SRC_TEXTURE(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_TEXTURE )
#define D3DVS_SRC_ADDR(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_ADDR )
#define D3DVS_SRC_RASTOUT(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_RASTOUT )
#define D3DVS_SRC_ATTROUT(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_ATTROUT )
#define D3DVS_SRC_TEXCRDOUT(_Num) ( D3DPS_REGNUM_MASK(_Num) | D3DSP_NOSWIZZLE | D3DSPR_TEXCRDOUT )
#define D3DS_DR0 D3DPS_DST(0)
#define D3DS_DR1 D3DPS_DST(1)
#define D3DS_DR2 D3DPS_DST(2)
#define D3DS_DR3 D3DPS_DST(3)
#define D3DS_DR4 D3DPS_DST(4)
#define D3DS_DR5 D3DPS_DST(5)
#define D3DS_DR6 D3DPS_DST(6)
#define D3DS_DR7 D3DPS_DST(7)
#define D3DS_SR0 D3DPS_SRC_TEMP(0)
#define D3DS_SR1 D3DPS_SRC_TEMP(1)
#define D3DS_SR2 D3DPS_SRC_TEMP(2)
#define D3DS_SR3 D3DPS_SRC_TEMP(3)
#define D3DS_SR4 D3DPS_SRC_TEMP(4)
#define D3DS_SR5 D3DPS_SRC_TEMP(5)
#define D3DS_SR6 D3DPS_SRC_TEMP(6)
#define D3DS_SR7 D3DPS_SRC_TEMP(7)
#define D3DS_T0 D3DPS_SRC_TEXTURE(0)
#define D3DS_T1 D3DPS_SRC_TEXTURE(1)
#define D3DS_T2 D3DPS_SRC_TEXTURE(2)
#define D3DS_T3 D3DPS_SRC_TEXTURE(3)
#define D3DS_T4 D3DPS_SRC_TEXTURE(4)
#define D3DS_T5 D3DPS_SRC_TEXTURE(5)
#define D3DS_T6 D3DPS_SRC_TEXTURE(6)
#define D3DS_T7 D3DPS_SRC_TEXTURE(7)
#define D3DS_C0 D3DPS_SRC_CONST(0)
#define D3DS_C1 D3DPS_SRC_CONST(1)
#define D3DS_C2 D3DPS_SRC_CONST(2)
#define D3DS_C3 D3DPS_SRC_CONST(3)
#define D3DS_C4 D3DPS_SRC_CONST(4)
#define D3DS_C5 D3DPS_SRC_CONST(5)
#define D3DS_C6 D3DPS_SRC_CONST(6)
#define D3DS_C7 D3DPS_SRC_CONST(7)
#define D3DS_V0 D3DPS_SRC_INPUT(0)
#define D3DS_V1 D3DPS_SRC_INPUT(1)
#endif
| C++ |
#define STRICT
#include <dmusicc.h>
#include <dmusici.h>
#include <dsound.h>
#include <dxerr8.h>
#include "DMUtil.h"
#include "DXUtil.h"
CMusicManager::CMusicManager()
{
m_pLoader = NULL;
m_pPerformance = NULL;
HRESULT hr = CoInitialize(NULL);
m_bCleanupCOM = SUCCEEDED(hr);
}
CMusicManager::~CMusicManager()
{
SAFE_RELEASE( m_pLoader );
if( m_pPerformance )
{
m_pPerformance->Stop( NULL, NULL, 0, 0 );
m_pPerformance->CloseDown();
SAFE_RELEASE( m_pPerformance );
}
if( m_bCleanupCOM )
CoUninitialize();
}
HRESULT CMusicManager::Initialize( HWND hWnd, DWORD dwPChannels, DWORD dwDefaultPathType )
{
HRESULT hr;
if( FAILED( hr = CoCreateInstance( CLSID_DirectMusicLoader, NULL, CLSCTX_INPROC,
IID_IDirectMusicLoader8, (void**)&m_pLoader ) ) )
return DXTRACE_ERR( TEXT("CoCreateInstance"), hr );
if( FAILED( hr = CoCreateInstance( CLSID_DirectMusicPerformance, NULL, CLSCTX_INPROC,
IID_IDirectMusicPerformance8, (void**)&m_pPerformance ) ) )
return DXTRACE_ERR( TEXT("CoCreateInstance"), hr );
if( FAILED( hr = m_pPerformance->InitAudio( NULL, NULL, hWnd, dwDefaultPathType,
dwPChannels, DMUS_AUDIOF_ALL, NULL ) ) )
{
if( hr == DSERR_NODRIVER )
{
DXTRACE( "Warning: No sound card found\n" );
return hr;
}
return DXTRACE_ERR( TEXT("InitAudio"), hr );
}
return S_OK;
}
HRESULT CMusicManager::SetSearchDirectory( const TCHAR* strMediaPath )
{
if( NULL == m_pLoader )
return E_UNEXPECTED;
WCHAR wstrMediaPath[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrMediaPath, strMediaPath );
return m_pLoader->SetSearchDirectory( GUID_DirectMusicAllTypes,
wstrMediaPath, FALSE );
}
IDirectMusicAudioPath8* CMusicManager::GetDefaultAudioPath()
{
IDirectMusicAudioPath8* pAudioPath = NULL;
if( NULL == m_pPerformance )
return NULL;
m_pPerformance->GetDefaultAudioPath( &pAudioPath );
return pAudioPath;
}
VOID CMusicManager::CollectGarbage()
{
if( m_pLoader )
m_pLoader->CollectGarbage();
}
HRESULT CMusicManager::CreateSegmentFromFile( CMusicSegment** ppSegment,
TCHAR* strFileName,
BOOL bDownloadNow,
BOOL bIsMidiFile )
{
HRESULT hr;
IDirectMusicSegment8* pSegment = NULL;
WCHAR wstrFileName[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrFileName, strFileName );
if ( FAILED( hr = m_pLoader->LoadObjectFromFile( CLSID_DirectMusicSegment,
IID_IDirectMusicSegment8,
wstrFileName,
(LPVOID*) &pSegment ) ) )
{
if( hr == DMUS_E_LOADER_FAILEDOPEN )
return hr;
return DXTRACE_ERR( TEXT("LoadObjectFromFile"), hr );
}
*ppSegment = new CMusicSegment( m_pPerformance, m_pLoader, pSegment );
if (!*ppSegment)
return E_OUTOFMEMORY;
if( bIsMidiFile )
{
if( FAILED( hr = pSegment->SetParam( GUID_StandardMIDIFile,
0xFFFFFFFF, 0, 0, NULL ) ) )
return DXTRACE_ERR( TEXT("SetParam"), hr );
}
if( bDownloadNow )
{
if( FAILED( hr = (*ppSegment)->Download() ) )
return DXTRACE_ERR( TEXT("Download"), hr );
}
return S_OK;
}
HRESULT CMusicManager::CreateSegmentFromResource( CMusicSegment** ppSegment,
TCHAR* strResource,
TCHAR* strResourceType,
BOOL bDownloadNow,
BOOL bIsMidiFile )
{
HRESULT hr;
IDirectMusicSegment8* pSegment = NULL;
HRSRC hres = NULL;
void* pMem = NULL;
DWORD dwSize = 0;
DMUS_OBJECTDESC objdesc;
hres = FindResource( NULL,strResource,strResourceType );
if( NULL == hres )
return E_FAIL;
pMem = (void*)LoadResource( NULL, hres );
if( NULL == pMem )
return E_FAIL;
dwSize = SizeofResource( NULL, hres );
ZeroMemory(&objdesc,sizeof(DMUS_OBJECTDESC));
objdesc.dwSize = sizeof(DMUS_OBJECTDESC);
objdesc.dwValidData = DMUS_OBJ_MEMORY | DMUS_OBJ_CLASS;
objdesc.guidClass = CLSID_DirectMusicSegment;
objdesc.llMemLength =(LONGLONG)dwSize;
objdesc.pbMemData = (BYTE*)pMem;
if (FAILED ( hr = m_pLoader->GetObject( &objdesc,
IID_IDirectMusicSegment8,
(void**)&pSegment ) ) )
{
if( hr == DMUS_E_LOADER_FAILEDOPEN )
return hr;
return DXTRACE_ERR( TEXT("LoadObjectFromFile"), hr );
}
*ppSegment = new CMusicSegment( m_pPerformance, m_pLoader, pSegment );
if( NULL == *ppSegment )
return E_OUTOFMEMORY;
if( bIsMidiFile )
{
if( FAILED( hr = pSegment->SetParam( GUID_StandardMIDIFile,
0xFFFFFFFF, 0, 0, NULL ) ) )
return DXTRACE_ERR( TEXT("SetParam"), hr );
}
if( bDownloadNow )
{
if( FAILED( hr = (*ppSegment)->Download() ) )
return DXTRACE_ERR( TEXT("Download"), hr );
}
return S_OK;
}
HRESULT CMusicManager::CreateScriptFromFile( CMusicScript** ppScript,
TCHAR* strFileName )
{
HRESULT hr;
IDirectMusicScript* pScript = NULL;
WCHAR wstrFileName[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrFileName, strFileName );
if ( FAILED( hr = m_pLoader->LoadObjectFromFile( CLSID_DirectMusicScript,
IID_IDirectMusicScript8,
wstrFileName,
(LPVOID*) &pScript ) ) )
return DXTRACE_ERR_NOMSGBOX( TEXT("LoadObjectFromFile"), hr );
if ( FAILED( hr = pScript->Init( m_pPerformance, NULL ) ) )
return DXTRACE_ERR( TEXT("Init"), hr );
*ppScript = new CMusicScript( m_pPerformance, m_pLoader, pScript );
if (!*ppScript)
return E_OUTOFMEMORY;
return hr;
}
HRESULT CMusicManager::CreateChordMapFromFile( IDirectMusicChordMap8** ppChordMap,
TCHAR* strFileName )
{
WCHAR wstrFileName[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrFileName, strFileName );
return m_pLoader->LoadObjectFromFile( CLSID_DirectMusicChordMap,
IID_IDirectMusicChordMap8,
wstrFileName, (LPVOID*) ppChordMap );
}
HRESULT CMusicManager::CreateStyleFromFile( IDirectMusicStyle8** ppStyle,
TCHAR* strFileName )
{
WCHAR wstrFileName[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrFileName, strFileName );
return m_pLoader->LoadObjectFromFile( CLSID_DirectMusicStyle,
IID_IDirectMusicStyle8,
wstrFileName, (LPVOID*) ppStyle );
}
HRESULT CMusicManager::GetMotifFromStyle( IDirectMusicSegment8** ppMotif8,
TCHAR* strStyle, TCHAR* strMotif )
{
HRESULT hr;
IDirectMusicStyle8* pStyle = NULL;
IDirectMusicSegment* pMotif = NULL;
if( FAILED( hr = CreateStyleFromFile( &pStyle, strStyle ) ) )
return DXTRACE_ERR( TEXT("CreateStyleFromFile"), hr );
if( pStyle )
{
WCHAR wstrMotif[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrMotif, strMotif );
hr = pStyle->GetMotif( wstrMotif, &pMotif );
SAFE_RELEASE( pStyle );
if( FAILED( hr ) )
return DXTRACE_ERR( TEXT("GetMotif"), hr );
pMotif->QueryInterface( IID_IDirectMusicSegment8, (LPVOID*) ppMotif8 );
}
return S_OK;
}
CMusicSegment::CMusicSegment( IDirectMusicPerformance8* pPerformance,
IDirectMusicLoader8* pLoader,
IDirectMusicSegment8* pSegment )
{
m_pPerformance = pPerformance;
m_pLoader = pLoader;
m_pSegment = pSegment;
m_pEmbeddedAudioPath = NULL;
m_bDownloaded = FALSE;
IUnknown* pConfig = NULL;
if( SUCCEEDED( m_pSegment->GetAudioPathConfig( &pConfig ) ) )
{
m_pPerformance->CreateAudioPath( pConfig, TRUE, &m_pEmbeddedAudioPath );
SAFE_RELEASE( pConfig );
}
}
CMusicSegment::~CMusicSegment()
{
if( m_pSegment )
{
if( m_pLoader )
m_pLoader->ReleaseObjectByUnknown( m_pSegment );
if( m_bDownloaded )
{
if( m_pEmbeddedAudioPath )
m_pSegment->Unload( m_pEmbeddedAudioPath );
else
m_pSegment->Unload( m_pPerformance );
}
SAFE_RELEASE( m_pEmbeddedAudioPath );
SAFE_RELEASE( m_pSegment );
}
m_pPerformance = NULL;
}
HRESULT CMusicSegment::Play( DWORD dwFlags, IDirectMusicAudioPath8* pAudioPath )
{
if( m_pSegment == NULL || m_pPerformance == NULL )
return CO_E_NOTINITIALIZED;
if( !m_bDownloaded )
return E_FAIL;
if( pAudioPath == NULL && m_pEmbeddedAudioPath != NULL )
pAudioPath = m_pEmbeddedAudioPath;
return m_pPerformance->PlaySegmentEx( m_pSegment, 0, NULL, dwFlags,
0, 0, NULL, pAudioPath );
}
HRESULT CMusicSegment::Download( IDirectMusicAudioPath8* pAudioPath )
{
HRESULT hr;
if( m_pSegment == NULL )
return CO_E_NOTINITIALIZED;
if( pAudioPath == NULL )
{
if( m_pEmbeddedAudioPath )
hr = m_pSegment->Download( m_pEmbeddedAudioPath );
else
hr = m_pSegment->Download( m_pPerformance );
}
else
{
hr = m_pSegment->Download( pAudioPath );
}
if ( SUCCEEDED( hr ) )
m_bDownloaded = TRUE;
return hr;
}
HRESULT CMusicSegment::Unload( IDirectMusicAudioPath8* pAudioPath )
{
HRESULT hr;
if( m_pSegment == NULL )
return CO_E_NOTINITIALIZED;
if( pAudioPath == NULL )
{
if( m_pEmbeddedAudioPath )
hr = m_pSegment->Unload( m_pEmbeddedAudioPath );
else
hr = m_pSegment->Unload( m_pPerformance );
}
else
{
hr = m_pSegment->Unload( pAudioPath );
}
if ( SUCCEEDED( hr ) )
m_bDownloaded = FALSE;
return hr;
}
BOOL CMusicSegment::IsPlaying()
{
if( m_pSegment == NULL || m_pPerformance == NULL )
return CO_E_NOTINITIALIZED;
return ( m_pPerformance->IsPlaying( m_pSegment, NULL ) == S_OK );
}
HRESULT CMusicSegment::Stop( DWORD dwFlags )
{
if( m_pSegment == NULL || m_pPerformance == NULL )
return CO_E_NOTINITIALIZED;
return m_pPerformance->Stop( m_pSegment, NULL, 0, dwFlags );;
}
HRESULT CMusicSegment::SetRepeats( DWORD dwRepeats )
{
if( m_pSegment == NULL )
return CO_E_NOTINITIALIZED;
return m_pSegment->SetRepeats( dwRepeats );
}
HRESULT CMusicSegment::GetStyle( IDirectMusicStyle8** ppStyle, DWORD dwStyleIndex )
{
return m_pSegment->GetParam( GUID_IDirectMusicStyle, 0xffffffff, dwStyleIndex,
0, NULL, (VOID*)ppStyle );
}
CMusicScript::CMusicScript( IDirectMusicPerformance8* pPerformance,
IDirectMusicLoader8* pLoader,
IDirectMusicScript8* pScript )
{
m_pPerformance = pPerformance;
m_pLoader = pLoader;
m_pScript = pScript;
}
CMusicScript::~CMusicScript()
{
if( m_pLoader )
{
m_pLoader->ReleaseObjectByUnknown( m_pScript );
m_pLoader = NULL;
}
SAFE_RELEASE( m_pScript );
m_pPerformance = NULL;
}
HRESULT CMusicScript::CallRoutine( TCHAR* strRoutine )
{
WCHAR wstrRoutine[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrRoutine, strRoutine );
return m_pScript->CallRoutine( wstrRoutine, NULL );
}
HRESULT CMusicScript::SetVariableNumber( TCHAR* strVariable, LONG lValue )
{
WCHAR wstrVariable[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrVariable, strVariable );
return m_pScript->SetVariableNumber( wstrVariable, lValue, NULL );
}
HRESULT CMusicScript::GetVariableNumber( TCHAR* strVariable, LONG* plValue )
{
WCHAR wstrVariable[MAX_PATH];
DXUtil_ConvertGenericStringToWide( wstrVariable, strVariable );
return m_pScript->GetVariableNumber( wstrVariable, plValue, NULL );
}
| C++ |
#define STRICT
#define DIRECTINPUT_VERSION 0x0800
#include <basetsd.h>
#include <tchar.h>
#include <stdio.h>
#include "DIUtil.h"
#include "DXUtil.h"
CInputDeviceManager::CInputDeviceManager()
{
HRESULT hr = CoInitialize(NULL);
m_bCleanupCOM = SUCCEEDED(hr);
m_dwNumDevices = 0;
m_dwMaxDevices = 10;
m_pDI = NULL;
m_pDevices = NULL;
m_pDevices = (DeviceInfo*) realloc( m_pDevices, m_dwMaxDevices*sizeof(DeviceInfo) );
ZeroMemory( m_pDevices, m_dwMaxDevices*sizeof(DeviceInfo) );
}
CInputDeviceManager::~CInputDeviceManager()
{
if( m_pDevices )
{
for( DWORD i=0; i<m_dwNumDevices; i++ )
{
m_pDevices[i].pdidDevice->Unacquire();
m_pDevices[i].pdidDevice->Release();
m_pDevices[i].pdidDevice = NULL;
}
if(m_pDevices)
free(m_pDevices);
}
SAFE_RELEASE( m_pDI );
if( m_bCleanupCOM )
CoUninitialize();
}
HRESULT CInputDeviceManager::GetDevices( DeviceInfo** ppDeviceInfo,
DWORD* pdwCount )
{
if( NULL==ppDeviceInfo || NULL==pdwCount )
return E_INVALIDARG;
(*ppDeviceInfo) = m_pDevices;
(*pdwCount) = m_dwNumDevices;
return S_OK;
}
HRESULT CInputDeviceManager::AddDevice( const DIDEVICEINSTANCE* pdidi,
const LPDIRECTINPUTDEVICE8 pdidDevice )
{
HRESULT hr;
DWORD dwDeviceType = pdidi->dwDevType;
pdidDevice->Unacquire();
hr = pdidDevice->SetCooperativeLevel( m_hWnd, DISCL_NONEXCLUSIVE|DISCL_FOREGROUND|DISCL_NOWINKEY );
if( FAILED(hr) )
return hr;
m_dwNumDevices++;
if( m_dwNumDevices > m_dwMaxDevices )
{
m_dwMaxDevices += 10;
m_pDevices = (DeviceInfo*) realloc( m_pDevices, m_dwMaxDevices*sizeof(DeviceInfo) );
ZeroMemory( m_pDevices + m_dwMaxDevices - 10, 10*sizeof(DeviceInfo) );
}
DWORD dwCurrentDevice = m_dwNumDevices-1;
m_pDevices[dwCurrentDevice].pdidDevice = pdidDevice;
m_pDevices[dwCurrentDevice].pdidDevice->AddRef();
if( m_AddDeviceCallback )
{
hr = m_AddDeviceCallback( &m_pDevices[dwCurrentDevice], pdidi, m_AddDeviceCallbackParam );
if( FAILED(hr) )
return hr;
}
hr = m_pDevices[dwCurrentDevice].pdidDevice->BuildActionMap( &m_diaf, m_strUserName, 0 );
if( FAILED(hr) )
return hr;
hr = m_pDevices[dwCurrentDevice].pdidDevice->SetActionMap( &m_diaf, m_strUserName, 0 );
if( FAILED(hr) )
return hr;
return S_OK;
}
BOOL CALLBACK EnumSuitableDevicesCB( LPCDIDEVICEINSTANCE pdidi,
LPDIRECTINPUTDEVICE8 pdidDevice,
DWORD dwFlags, DWORD dwDeviceRemaining,
VOID* pContext )
{
((CInputDeviceManager*)pContext)->AddDevice( pdidi, pdidDevice );
return DIENUM_CONTINUE;
}
HRESULT CInputDeviceManager::SetActionFormat( DIACTIONFORMAT& diaf, BOOL bReenumerate )
{
HRESULT hr = S_OK;
m_diaf = diaf;
if( bReenumerate )
{
for( DWORD i=0; i<m_dwNumDevices; i++ )
{
m_pDevices[i].pdidDevice->Unacquire();
m_pDevices[i].pdidDevice->Release();
m_pDevices[i].pdidDevice = NULL;
}
m_dwNumDevices = 0;
hr = m_pDI->EnumDevicesBySemantics( m_strUserName, &m_diaf,
EnumSuitableDevicesCB, this, 0L );
if( FAILED(hr) )
return hr;
}
else
{
UnacquireDevices();
for( DWORD i=0; i<m_dwNumDevices; i++ )
{
hr = m_pDevices[i].pdidDevice->BuildActionMap( &m_diaf, m_strUserName, 0 );
if( FAILED(hr) )
return hr;
hr = m_pDevices[i].pdidDevice->SetActionMap( &m_diaf, m_strUserName, 0 );
if( FAILED(hr) )
return hr;
}
}
if( FAILED(hr) )
return hr;
return S_OK;
}
HRESULT CInputDeviceManager::Create( HWND hWnd, TCHAR* strUserName,
DIACTIONFORMAT& diaf,
LPDIMANAGERCALLBACK AddDeviceCallback,
LPVOID pCallbackParam )
{
HRESULT hr;
m_hWnd = hWnd;
m_strUserName = strUserName;
m_AddDeviceCallback = AddDeviceCallback;
m_AddDeviceCallbackParam = pCallbackParam;
hr = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&m_pDI, NULL );
if( FAILED(hr) )
return hr;
hr = SetActionFormat( diaf, TRUE );
if( FAILED(hr) )
return hr;
return S_OK;
}
HRESULT CInputDeviceManager::ConfigureDevices( HWND hWnd, IUnknown* pSurface,
VOID* ConfigureDevicesCB,
DWORD dwFlags, LPVOID pvCBParam )
{
HRESULT hr;
DICOLORSET dics;
ZeroMemory(&dics, sizeof(DICOLORSET));
dics.dwSize = sizeof(DICOLORSET);
DICONFIGUREDEVICESPARAMS dicdp;
ZeroMemory(&dicdp, sizeof(dicdp));
dicdp.dwSize = sizeof(dicdp);
dicdp.dwcFormats = 1;
dicdp.lprgFormats = &m_diaf;
dicdp.hwnd = hWnd;
dicdp.lpUnkDDSTarget = pSurface;
if( m_strUserName )
{
dicdp.dwcUsers = 1;
dicdp.lptszUserNames = m_strUserName;
}
UnacquireDevices();
hr = m_pDI->ConfigureDevices( (LPDICONFIGUREDEVICESCALLBACK)ConfigureDevicesCB,
&dicdp, dwFlags, pvCBParam );
if( FAILED(hr) )
return hr;
if( dwFlags & DICD_EDIT )
{
hr = SetActionFormat( m_diaf, TRUE );
if( FAILED(hr) )
return hr;
}
return S_OK;
}
VOID CInputDeviceManager::UnacquireDevices()
{
for( DWORD i=0; i<m_dwNumDevices; i++ )
m_pDevices[i].pdidDevice->Unacquire();
}
VOID CInputDeviceManager::SetFocus( HWND hWnd )
{
m_hWnd = hWnd;
UnacquireDevices();
for( DWORD i=0; i<m_dwNumDevices; i++ )
{
m_pDevices[i].pdidDevice->SetCooperativeLevel( m_hWnd,
DISCL_NONEXCLUSIVE|DISCL_FOREGROUND|DISCL_NOWINKEY );
}
}
| C++ |
#define STRICT
#include <tchar.h>
#include <stdio.h>
#include "D3DUtil.h"
#include "DXUtil.h"
#include "D3DX8.h"
VOID D3DUtil_InitMaterial( D3DMATERIAL8& mtrl, FLOAT r, FLOAT g, FLOAT b,
FLOAT a )
{
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
mtrl.Diffuse.r = mtrl.Ambient.r = r;
mtrl.Diffuse.g = mtrl.Ambient.g = g;
mtrl.Diffuse.b = mtrl.Ambient.b = b;
mtrl.Diffuse.a = mtrl.Ambient.a = a;
}
VOID D3DUtil_InitLight( D3DLIGHT8& light, D3DLIGHTTYPE ltType,
FLOAT x, FLOAT y, FLOAT z )
{
ZeroMemory( &light, sizeof(D3DLIGHT8) );
light.Type = ltType;
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &D3DXVECTOR3(x, y, z) );
light.Position.x = x;
light.Position.y = y;
light.Position.z = z;
light.Range = 1000.0f;
}
HRESULT D3DUtil_CreateTexture( LPDIRECT3DDEVICE8 pd3dDevice, TCHAR* strTexture,
LPDIRECT3DTEXTURE8* ppTexture, D3DFORMAT d3dFormat )
{
TCHAR strPath[MAX_PATH];
DXUtil_FindMediaFile( strPath, strTexture );
return D3DXCreateTextureFromFileEx( pd3dDevice, strPath,
D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, d3dFormat,
D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE|D3DX_FILTER_MIRROR,
D3DX_FILTER_TRIANGLE|D3DX_FILTER_MIRROR, 0, NULL, NULL, ppTexture );
}
HRESULT D3DUtil_SetColorKey( LPDIRECT3DTEXTURE8 pTexture, DWORD dwColorKey )
{
DWORD r = ((dwColorKey&0x00ff0000)>>16);
DWORD g = ((dwColorKey&0x0000ff00)>>8);
DWORD b = ((dwColorKey&0x000000ff)>>0);
D3DSURFACE_DESC d3dsd;
pTexture->GetLevelDesc( 0, &d3dsd );
if( d3dsd.Format == D3DFMT_A4R4G4B4 )
dwColorKey = 0xf000 + ((r>>4)<<8) + ((g>>4)<<4) + (b>>4);
else if( d3dsd.Format == D3DFMT_A1R5G5B5 )
dwColorKey = 0x8000 + ((r>>3)<<10) + ((g>>3)<<5) + (b>>3);
else if( d3dsd.Format != D3DFMT_A8R8G8B8 )
return E_FAIL;
D3DLOCKED_RECT d3dlr;
if( FAILED( pTexture->LockRect( 0, &d3dlr, 0, 0 ) ) )
return E_FAIL;
for( DWORD y=0; y<d3dsd.Height; y++ )
{
for( DWORD x=0; x<d3dsd.Width; x++ )
{
if( d3dsd.Format==D3DFMT_A8R8G8B8 )
{
if( ((DWORD*)d3dlr.pBits)[d3dsd.Width*y+x] == dwColorKey )
((DWORD*)d3dlr.pBits)[d3dsd.Width*y+x] = 0x00000000;
}
else
{
if( ((WORD*)d3dlr.pBits)[d3dsd.Width*y+x] == dwColorKey )
((WORD*)d3dlr.pBits)[d3dsd.Width*y+x] = 0x0000;
}
}
}
pTexture->UnlockRect(0);
return S_OK;
}
HRESULT D3DUtil_CreateVertexShader( LPDIRECT3DDEVICE8 pd3dDevice,
TCHAR* strFilename, DWORD* pdwVertexDecl,
DWORD* pdwVertexShader )
{
LPD3DXBUFFER pCode;
TCHAR strPath[MAX_PATH];
HRESULT hr;
DXUtil_FindMediaFile( strPath, strFilename );
if( FAILED( hr = D3DXAssembleShaderFromFile( strPath, 0, NULL, &pCode, NULL ) ) )
return hr;
hr = pd3dDevice->CreateVertexShader( pdwVertexDecl,
(DWORD*)pCode->GetBufferPointer(),
pdwVertexShader, 0 );
pCode->Release();
return hr;
}
D3DXMATRIX D3DUtil_GetCubeMapViewMatrix( DWORD dwFace )
{
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vLookDir;
D3DXVECTOR3 vUpDir;
switch( dwFace )
{
case D3DCUBEMAP_FACE_POSITIVE_X:
vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_X:
vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_POSITIVE_Y:
vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
break;
case D3DCUBEMAP_FACE_POSITIVE_Z:
vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
}
D3DXMATRIX matView;
D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookDir, &vUpDir );
return matView;
}
D3DXQUATERNION D3DUtil_GetRotationFromCursor( HWND hWnd,
FLOAT fTrackBallRadius )
{
POINT pt;
RECT rc;
GetCursorPos( &pt );
GetClientRect( hWnd, &rc );
ScreenToClient( hWnd, &pt );
FLOAT sx = ( ( ( 2.0f * pt.x ) / (rc.right-rc.left) ) - 1 );
FLOAT sy = ( ( ( 2.0f * pt.y ) / (rc.bottom-rc.top) ) - 1 );
FLOAT sz;
if( sx == 0.0f && sy == 0.0f )
return D3DXQUATERNION( 0.0f, 0.0f, 0.0f, 1.0f );
FLOAT d1 = 0.0f;
FLOAT d2 = sqrtf( sx*sx + sy*sy );
if( d2 < fTrackBallRadius * 0.70710678118654752440 )
sz = sqrtf( fTrackBallRadius*fTrackBallRadius - d2*d2 );
else
sz = (fTrackBallRadius*fTrackBallRadius) / (2.0f*d2);
D3DXVECTOR3 p1( sx, sy, sz );
D3DXVECTOR3 p2( 0.0f, 0.0f, fTrackBallRadius );
D3DXVECTOR3 vAxis;
D3DXVec3Cross( &vAxis, &p1, &p2);
FLOAT t = D3DXVec3Length( &(p2-p1) ) / ( 2.0f*fTrackBallRadius );
if( t > +1.0f) t = +1.0f;
if( t < -1.0f) t = -1.0f;
FLOAT fAngle = 2.0f * asinf( t );
D3DXQUATERNION quat;
D3DXQuaternionRotationAxis( &quat, &vAxis, fAngle );
return quat;
}
HRESULT D3DUtil_SetDeviceCursor( LPDIRECT3DDEVICE8 pd3dDevice, HCURSOR hCursor,
BOOL bAddWatermark )
{
HRESULT hr = E_FAIL;
ICONINFO iconinfo;
BOOL bBWCursor;
LPDIRECT3DSURFACE8 pCursorBitmap = NULL;
HDC hdcColor = NULL;
HDC hdcMask = NULL;
HDC hdcScreen = NULL;
BITMAP bm;
DWORD dwWidth;
DWORD dwHeightSrc;
DWORD dwHeightDest;
COLORREF crColor;
COLORREF crMask;
UINT x;
UINT y;
BITMAPINFO bmi;
COLORREF* pcrArrayColor = NULL;
COLORREF* pcrArrayMask = NULL;
DWORD* pBitmap;
HGDIOBJ hgdiobjOld;
ZeroMemory( &iconinfo, sizeof(iconinfo) );
if( !GetIconInfo( hCursor, &iconinfo ) )
goto End;
if (0 == GetObject((HGDIOBJ)iconinfo.hbmMask, sizeof(BITMAP), (LPVOID)&bm))
goto End;
dwWidth = bm.bmWidth;
dwHeightSrc = bm.bmHeight;
if( iconinfo.hbmColor == NULL )
{
bBWCursor = TRUE;
dwHeightDest = dwHeightSrc / 2;
}
else
{
bBWCursor = FALSE;
dwHeightDest = dwHeightSrc;
}
if( FAILED( hr = pd3dDevice->CreateImageSurface( dwWidth, dwHeightDest,
D3DFMT_A8R8G8B8, &pCursorBitmap ) ) )
{
goto End;
}
pcrArrayMask = new DWORD[dwWidth * dwHeightSrc];
ZeroMemory(&bmi, sizeof(bmi));
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = dwWidth;
bmi.bmiHeader.biHeight = dwHeightSrc;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
hdcScreen = GetDC( NULL );
hdcMask = CreateCompatibleDC( hdcScreen );
if( hdcMask == NULL )
{
hr = E_FAIL;
goto End;
}
hgdiobjOld = SelectObject(hdcMask, iconinfo.hbmMask);
GetDIBits(hdcMask, iconinfo.hbmMask, 0, dwHeightSrc,
pcrArrayMask, &bmi, DIB_RGB_COLORS);
SelectObject(hdcMask, hgdiobjOld);
if (!bBWCursor)
{
pcrArrayColor = new DWORD[dwWidth * dwHeightDest];
hdcColor = CreateCompatibleDC( GetDC( NULL ) );
if( hdcColor == NULL )
{
hr = E_FAIL;
goto End;
}
SelectObject(hdcColor, iconinfo.hbmColor);
GetDIBits(hdcColor, iconinfo.hbmColor, 0, dwHeightDest,
pcrArrayColor, &bmi, DIB_RGB_COLORS);
}
D3DLOCKED_RECT lr;
pCursorBitmap->LockRect( &lr, NULL, 0 );
pBitmap = (DWORD*)lr.pBits;
for( y = 0; y < dwHeightDest; y++ )
{
for( x = 0; x < dwWidth; x++ )
{
if (bBWCursor)
{
crColor = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x];
crMask = pcrArrayMask[dwWidth*(dwHeightSrc-1-y) + x];
}
else
{
crColor = pcrArrayColor[dwWidth*(dwHeightDest-1-y) + x];
crMask = pcrArrayMask[dwWidth*(dwHeightDest-1-y) + x];
}
if (crMask == 0)
pBitmap[dwWidth*y + x] = 0xff000000 | crColor;
else
pBitmap[dwWidth*y + x] = 0x00000000;
if( bAddWatermark && x < 12 && y < 5 )
{
const WORD wMask[5] = { 0xccc0, 0xa2a0, 0xa4a0, 0xa2a0, 0xccc0 };
if( wMask[y] & (1 << (15 - x)) )
{
pBitmap[dwWidth*y + x] |= 0xff808080;
}
}
}
}
pCursorBitmap->UnlockRect();
if( FAILED( hr = pd3dDevice->SetCursorProperties( iconinfo.xHotspot,
iconinfo.yHotspot, pCursorBitmap ) ) )
{
goto End;
}
hr = S_OK;
End:
if( iconinfo.hbmMask != NULL )
DeleteObject( iconinfo.hbmMask );
if( iconinfo.hbmColor != NULL )
DeleteObject( iconinfo.hbmColor );
if( hdcScreen != NULL )
ReleaseDC( NULL, hdcScreen );
if( hdcColor != NULL )
DeleteDC( hdcColor );
if( hdcMask != NULL )
DeleteDC( hdcMask );
SAFE_DELETE_ARRAY( pcrArrayColor );
SAFE_DELETE_ARRAY( pcrArrayMask );
SAFE_RELEASE( pCursorBitmap );
return hr;
}
inline D3DXQUATERNION* WINAPI D3DXQuaternionUnitAxisToUnitAxis2
( D3DXQUATERNION *pOut, const D3DXVECTOR3 *pvFrom, const D3DXVECTOR3 *pvTo)
{
D3DXVECTOR3 vAxis;
D3DXVec3Cross(&vAxis, pvFrom, pvTo);
pOut->x = vAxis.x;
pOut->y = vAxis.y;
pOut->z = vAxis.z;
pOut->w = D3DXVec3Dot( pvFrom, pvTo );
return pOut;
}
inline D3DXQUATERNION* WINAPI D3DXQuaternionAxisToAxis
( D3DXQUATERNION *pOut, const D3DXVECTOR3 *pvFrom, const D3DXVECTOR3 *pvTo)
{
D3DXVECTOR3 vA, vB;
D3DXVec3Normalize(&vA, pvFrom);
D3DXVec3Normalize(&vB, pvTo);
D3DXVECTOR3 vHalf(vA + vB);
D3DXVec3Normalize(&vHalf, &vHalf);
return D3DXQuaternionUnitAxisToUnitAxis2(pOut, &vA, &vHalf);
}
CD3DArcBall::CD3DArcBall()
{
D3DXQuaternionIdentity( &m_qDown );
D3DXQuaternionIdentity( &m_qNow );
D3DXMatrixIdentity( &m_matRotation );
D3DXMatrixIdentity( &m_matRotationDelta );
D3DXMatrixIdentity( &m_matTranslation );
D3DXMatrixIdentity( &m_matTranslationDelta );
m_bDrag = FALSE;
m_fRadiusTranslation = 1.0f;
m_bRightHanded = FALSE;
}
VOID CD3DArcBall::SetWindow( int iWidth, int iHeight, float fRadius )
{
m_iWidth = iWidth;
m_iHeight = iHeight;
m_fRadius = fRadius;
}
D3DXVECTOR3 CD3DArcBall::ScreenToVector( int sx, int sy )
{
FLOAT x = -(sx - m_iWidth/2) / (m_fRadius*m_iWidth/2);
FLOAT y = (sy - m_iHeight/2) / (m_fRadius*m_iHeight/2);
if( m_bRightHanded )
{
x = -x;
y = -y;
}
FLOAT z = 0.0f;
FLOAT mag = x*x + y*y;
if( mag > 1.0f )
{
FLOAT scale = 1.0f/sqrtf(mag);
x *= scale;
y *= scale;
}
else
z = sqrtf( 1.0f - mag );
return D3DXVECTOR3( x, y, z );
}
VOID CD3DArcBall::SetRadius( FLOAT fRadius )
{
m_fRadiusTranslation = fRadius;
}
LRESULT CD3DArcBall::HandleMouseMessages( HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam )
{
static int iCurMouseX;
static int iCurMouseY;
static D3DXVECTOR3 s_vDown;
int iMouseX = LOWORD(lParam);
int iMouseY = HIWORD(lParam);
switch( uMsg )
{
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
iCurMouseX = iMouseX;
iCurMouseY = iMouseY;
return TRUE;
case WM_LBUTTONDOWN:
m_bDrag = TRUE;
s_vDown = ScreenToVector( iMouseX, iMouseY );
m_qDown = m_qNow;
return TRUE;
case WM_LBUTTONUP:
m_bDrag = FALSE;
return TRUE;
case WM_MOUSEMOVE:
if( MK_LBUTTON&wParam )
{
if( m_bDrag )
{
D3DXVECTOR3 vCur = ScreenToVector( iMouseX, iMouseY );
D3DXQUATERNION qAxisToAxis;
D3DXQuaternionAxisToAxis(&qAxisToAxis, &s_vDown, &vCur);
m_qNow = m_qDown;
m_qNow *= qAxisToAxis;
D3DXMatrixRotationQuaternion(&m_matRotationDelta, &qAxisToAxis);
}
else
D3DXMatrixIdentity(&m_matRotationDelta);
D3DXMatrixRotationQuaternion(&m_matRotation, &m_qNow);
m_bDrag = TRUE;
}
else if( (MK_RBUTTON&wParam) || (MK_MBUTTON&wParam) )
{
FLOAT fDeltaX = ( iCurMouseX-iMouseX ) * m_fRadiusTranslation / m_iWidth;
FLOAT fDeltaY = ( iCurMouseY-iMouseY ) * m_fRadiusTranslation / m_iHeight;
if( wParam & MK_RBUTTON )
{
D3DXMatrixTranslation( &m_matTranslationDelta, -2*fDeltaX, 2*fDeltaY, 0.0f );
D3DXMatrixMultiply( &m_matTranslation, &m_matTranslation, &m_matTranslationDelta );
}
else
{
D3DXMatrixTranslation( &m_matTranslationDelta, 0.0f, 0.0f, 5*fDeltaY );
D3DXMatrixMultiply( &m_matTranslation, &m_matTranslation, &m_matTranslationDelta );
}
iCurMouseX = iMouseX;
iCurMouseY = iMouseY;
}
return TRUE;
}
return FALSE;
}
CD3DCamera::CD3DCamera()
{
SetViewParams( D3DXVECTOR3(0.0f,0.0f,0.0f), D3DXVECTOR3(0.0f,0.0f,1.0f),
D3DXVECTOR3(0.0f,1.0f,0.0f) );
SetProjParams( D3DX_PI/4, 1.0f, 1.0f, 1000.0f );
}
VOID CD3DCamera::SetViewParams( D3DXVECTOR3 &vEyePt, D3DXVECTOR3& vLookatPt,
D3DXVECTOR3& vUpVec )
{
m_vEyePt = vEyePt;
m_vLookatPt = vLookatPt;
m_vUpVec = vUpVec;
D3DXVec3Normalize( &m_vView, &(m_vLookatPt - m_vEyePt) );
D3DXVec3Cross( &m_vCross, &m_vView, &m_vUpVec );
D3DXMatrixLookAtLH( &m_matView, &m_vEyePt, &m_vLookatPt, &m_vUpVec );
D3DXMatrixInverse( &m_matBillboard, NULL, &m_matView );
m_matBillboard._41 = 0.0f;
m_matBillboard._42 = 0.0f;
m_matBillboard._43 = 0.0f;
}
VOID CD3DCamera::SetProjParams( FLOAT fFOV, FLOAT fAspect, FLOAT fNearPlane,
FLOAT fFarPlane )
{
m_fFOV = fFOV;
m_fAspect = fAspect;
m_fNearPlane = fNearPlane;
m_fFarPlane = fFarPlane;
D3DXMatrixPerspectiveFovLH( &m_matProj, fFOV, fAspect, fNearPlane, fFarPlane );
}
| C++ |
#define STRICT
#include <windows.h>
#include <mmsystem.h>
#include <dxerr8.h>
#include <dsound.h>
#include "DSUtil.h"
#include "DXUtil.h"
CSoundManager::CSoundManager()
{
m_pDS = NULL;
}
CSoundManager::~CSoundManager()
{
SAFE_RELEASE( m_pDS );
}
HRESULT CSoundManager::Initialize( HWND hWnd,
DWORD dwCoopLevel,
DWORD dwPrimaryChannels,
DWORD dwPrimaryFreq,
DWORD dwPrimaryBitRate )
{
HRESULT hr;
SAFE_RELEASE( m_pDS );
if( FAILED( hr = DirectSoundCreate8( NULL, &m_pDS, NULL ) ) )
return DXTRACE_ERR( TEXT("DirectSoundCreate8"), hr );
if( FAILED( hr = m_pDS->SetCooperativeLevel( hWnd, dwCoopLevel ) ) )
return DXTRACE_ERR( TEXT("SetCooperativeLevel"), hr );
if( FAILED( hr = SetPrimaryBufferFormat( dwPrimaryChannels, dwPrimaryFreq, dwPrimaryBitRate ) ) )
return DXTRACE_ERR( TEXT("SetPrimaryBufferFormat"), hr );
return S_OK;
}
HRESULT CSoundManager::SetPrimaryBufferFormat( DWORD dwPrimaryChannels,
DWORD dwPrimaryFreq,
DWORD dwPrimaryBitRate )
{
HRESULT hr;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
if( m_pDS == NULL )
return CO_E_NOTINITIALIZED;
DSBUFFERDESC dsbd;
ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) );
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
dsbd.dwBufferBytes = 0;
dsbd.lpwfxFormat = NULL;
if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ) ) )
return DXTRACE_ERR( TEXT("CreateSoundBuffer"), hr );
WAVEFORMATEX wfx;
ZeroMemory( &wfx, sizeof(WAVEFORMATEX) );
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = (WORD) dwPrimaryChannels;
wfx.nSamplesPerSec = dwPrimaryFreq;
wfx.wBitsPerSample = (WORD) dwPrimaryBitRate;
wfx.nBlockAlign = (WORD) (wfx.wBitsPerSample / 8 * wfx.nChannels);
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
if( FAILED( hr = pDSBPrimary->SetFormat(&wfx) ) )
return DXTRACE_ERR( TEXT("SetFormat"), hr );
SAFE_RELEASE( pDSBPrimary );
return S_OK;
}
HRESULT CSoundManager::Get3DListenerInterface( LPDIRECTSOUND3DLISTENER* ppDSListener )
{
HRESULT hr;
DSBUFFERDESC dsbdesc;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
if( ppDSListener == NULL )
return E_INVALIDARG;
if( m_pDS == NULL )
return CO_E_NOTINITIALIZED;
*ppDSListener = NULL;
ZeroMemory( &dsbdesc, sizeof(DSBUFFERDESC) );
dsbdesc.dwSize = sizeof(DSBUFFERDESC);
dsbdesc.dwFlags = DSBCAPS_CTRL3D | DSBCAPS_PRIMARYBUFFER;
if( FAILED( hr = m_pDS->CreateSoundBuffer( &dsbdesc, &pDSBPrimary, NULL ) ) )
return DXTRACE_ERR( TEXT("CreateSoundBuffer"), hr );
if( FAILED( hr = pDSBPrimary->QueryInterface( IID_IDirectSound3DListener,
(VOID**)ppDSListener ) ) )
{
SAFE_RELEASE( pDSBPrimary );
return DXTRACE_ERR( TEXT("QueryInterface"), hr );
}
SAFE_RELEASE( pDSBPrimary );
return S_OK;
}
HRESULT CSoundManager::Create( CSound* pSound,
LPTSTR strWaveFileName,
DWORD dwCreationFlags,
GUID guid3DAlgorithm )
{
HRESULT hr;
HRESULT hrRet = S_OK;
DWORD dwDSBufferSize = NULL;
CWaveFile* pWaveFile = NULL;
if( m_pDS == NULL )
return CO_E_NOTINITIALIZED;
if( strWaveFileName == NULL || pSound == NULL )
return E_INVALIDARG;
pWaveFile = new CWaveFile();
if( pWaveFile == NULL )
{
hr = E_OUTOFMEMORY;
goto LFail;
}
pWaveFile->Open( strWaveFileName , WAVEFILE_READ );
if( pWaveFile->GetSize() == 0 )
{
hr = E_FAIL;
goto LFail;
}
dwDSBufferSize = pWaveFile->GetSize();
DSBUFFERDESC dsbd;
ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) );
dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = dwCreationFlags;
dsbd.dwBufferBytes = dwDSBufferSize;
dsbd.guid3DAlgorithm = guid3DAlgorithm;
dsbd.lpwfxFormat = &pWaveFile->m_pwfx;
hr = m_pDS->CreateSoundBuffer( &dsbd, &pSound->m_apDSBuffer, NULL );
if( hr == DS_NO_VIRTUALIZATION )
hrRet = DS_NO_VIRTUALIZATION;
if( FAILED(hr) )
{
if( hr != DSERR_BUFFERTOOSMALL )
DXTRACE_ERR( TEXT("CreateSoundBuffer"), hr );
goto LFail;
}
hr = pSound->Create( dwDSBufferSize, pWaveFile );
if( FAILED( hr ) )
goto LFail;
return hrRet;
LFail:
SAFE_DELETE( pWaveFile );
return hr;
}
CSound::CSound()
{
m_apDSBuffer = NULL;
m_dwDSBufferSize = 0;
m_pDS3DBuffer = NULL;
m_pWaveFile = NULL;
}
HRESULT CSound::Create( DWORD dwDSBufferSize, CWaveFile* pWaveFile )
{
m_dwDSBufferSize = dwDSBufferSize;
m_pWaveFile = pWaveFile;
if( FAILED( FillBufferWithSound( m_apDSBuffer, FALSE, m_dwDSBufferSize ) ) )
return E_FAIL;
m_apDSBuffer->SetCurrentPosition(0);
return S_OK;
}
void CSound::Release()
{
SAFE_RELEASE( m_pDS3DBuffer );
SAFE_RELEASE( m_apDSBuffer );
SAFE_DELETE( m_pWaveFile );
}
CSound::~CSound()
{
}
HRESULT CSound::FillBufferWithSound( LPDIRECTSOUNDBUFFER pDSB, int bRepeatWavIfBufferLarger , DWORD sizeBuffer )
{
HRESULT hr;
VOID* pDSLockedBuffer = NULL;
DWORD dwDSLockedBufferSize = 0;
DWORD dwWavDataRead = 0;
if( pDSB == NULL )
return CO_E_NOTINITIALIZED;
if( FAILED( hr = RestoreBuffer( pDSB, NULL ) ) )
return DXTRACE_ERR( TEXT("RestoreBuffer"), hr );
if( sizeBuffer < m_dwDSBufferSize )
return E_FAIL;
if( FAILED( hr = pDSB->Lock( 0, sizeBuffer,
&pDSLockedBuffer, &dwDSLockedBufferSize,
NULL, NULL, 0L ) ) )
return DXTRACE_ERR( TEXT("Lock"), hr );
m_pWaveFile->ResetFile();
if( FAILED( hr = m_pWaveFile->Read( (BYTE*) pDSLockedBuffer,
dwDSLockedBufferSize,
&dwWavDataRead ) ) )
return DXTRACE_ERR( TEXT("Read"), hr );
if( dwWavDataRead == 0 )
{
FillMemory( (BYTE*) pDSLockedBuffer,
dwDSLockedBufferSize,
(BYTE)(m_pWaveFile->m_pwfx.wBitsPerSample == 8 ? 128 : 0 ) );
}
else if( dwWavDataRead < dwDSLockedBufferSize )
{
if( bRepeatWavIfBufferLarger )
{
DWORD dwReadSoFar = dwWavDataRead;
while( dwReadSoFar < dwDSLockedBufferSize )
{
if( FAILED( hr = m_pWaveFile->ResetFile() ) )
return DXTRACE_ERR( TEXT("ResetFile"), hr );
hr = m_pWaveFile->Read( (BYTE*)pDSLockedBuffer + dwReadSoFar,
dwDSLockedBufferSize - dwReadSoFar,
&dwWavDataRead );
if( FAILED(hr) )
return DXTRACE_ERR( TEXT("Read"), hr );
dwReadSoFar += dwWavDataRead;
}
}
else
{
FillMemory( (BYTE*) pDSLockedBuffer + dwWavDataRead,
dwDSLockedBufferSize - dwWavDataRead,
(BYTE)(m_pWaveFile->m_pwfx.wBitsPerSample == 8 ? 128 : 0 ) );
}
}
else if( dwWavDataRead < sizeBuffer )
{
FillMemory( (BYTE*) ( (BYTE*) pDSLockedBuffer + dwWavDataRead ),
sizeBuffer - dwWavDataRead,
(BYTE)(m_pWaveFile->m_pwfx.wBitsPerSample == 8 ? 128 : 0 ) );
}
pDSB->Unlock( pDSLockedBuffer, dwDSLockedBufferSize, NULL, 0 );
return S_OK;
}
HRESULT CSound::RestoreBuffer( LPDIRECTSOUNDBUFFER pDSB, BOOL* pbWasRestored )
{
HRESULT hr;
if( pDSB == NULL )
return CO_E_NOTINITIALIZED;
if( pbWasRestored )
*pbWasRestored = FALSE;
DWORD dwStatus;
if( FAILED( hr = pDSB->GetStatus( &dwStatus ) ) )
return DXTRACE_ERR( TEXT("GetStatus"), hr );
if( dwStatus & DSBSTATUS_BUFFERLOST )
{
do
{
hr = pDSB->Restore();
if( hr == DSERR_BUFFERLOST )
Sleep( 10 );
}
while( hr != DS_OK );
if( pbWasRestored != NULL )
*pbWasRestored = TRUE;
return S_OK;
}
else
{
return S_FALSE;
}
}
HRESULT CSound::Get3DBufferInterface( LPDIRECTSOUND3DBUFFER* ppDS3DBuffer )
{
if( m_apDSBuffer == NULL )
return CO_E_NOTINITIALIZED;
*ppDS3DBuffer = NULL;
return m_apDSBuffer->QueryInterface( IID_IDirectSound3DBuffer, (VOID**)ppDS3DBuffer );
}
HRESULT CSound::Play( LPDIRECTSOUNDBUFFER pDSB, DWORD sizeBuffer, DWORD dwPriority, DWORD dwFlags )
{
HRESULT hr;
BOOL bRestored;
if( m_apDSBuffer == NULL )
return CO_E_NOTINITIALIZED;
if( pDSB == NULL )
return DXTRACE_ERR( TEXT("CSound::Play"), E_FAIL );
if( FAILED( hr = RestoreBuffer( pDSB, &bRestored ) ) )
return DXTRACE_ERR( TEXT("RestoreBuffer"), hr );
if( bRestored )
{
if( FAILED( hr = FillBufferWithSound( pDSB, FALSE, sizeBuffer ) ) )
return DXTRACE_ERR( TEXT("FillBufferWithSound"), hr );
Reset( pDSB );
}
return pDSB->Play( 0, dwPriority, dwFlags );
}
HRESULT CSound::Stop( LPDIRECTSOUNDBUFFER pDSB )
{
if( pDSB == NULL )
return CO_E_NOTINITIALIZED;
HRESULT hr = 0;
hr = pDSB->Stop();
return hr;
}
HRESULT CSound::Reset( LPDIRECTSOUNDBUFFER pDSB )
{
if( pDSB == NULL )
return CO_E_NOTINITIALIZED;
HRESULT hr = 0;
hr = pDSB->SetCurrentPosition( 0 );
return hr;
}
int CSound::IsSoundPlaying( LPDIRECTSOUNDBUFFER pDSB )
{
int bIsPlaying = FALSE;
if( pDSB == NULL )
return FALSE;
DWORD dwStatus = 0;
pDSB->GetStatus( &dwStatus );
bIsPlaying = ( ( dwStatus & DSBSTATUS_PLAYING ) != 0 );
return bIsPlaying;
}
CWaveFile::CWaveFile()
{
m_hmmio = NULL;
m_pResourceBuffer = NULL;
m_dwSize = 0;
m_bIsReadingFromMemory = FALSE;
}
CWaveFile::~CWaveFile()
{
Close();
}
HRESULT CWaveFile::Open( LPTSTR strFileName, DWORD dwFlags )
{
HRESULT hr;
m_dwFlags = dwFlags;
m_bIsReadingFromMemory = FALSE;
if( m_dwFlags == WAVEFILE_READ )
{
if( strFileName == NULL )
return E_INVALIDARG;
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
if( NULL == m_hmmio )
{
HRSRC hResInfo;
HGLOBAL hResData;
DWORD dwSize;
VOID* pvRes;
if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT("WAVE") ) ) )
{
if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT("WAV") ) ) )
return DXTRACE_ERR_NOMSGBOX( TEXT("FindResource"), E_FAIL );
}
if( NULL == ( hResData = LoadResource( NULL, hResInfo ) ) )
return DXTRACE_ERR( TEXT("LoadResource"), E_FAIL );
if( 0 == ( dwSize = SizeofResource( NULL, hResInfo ) ) )
return DXTRACE_ERR( TEXT("SizeofResource"), E_FAIL );
if( NULL == ( pvRes = LockResource( hResData ) ) )
return DXTRACE_ERR( TEXT("LockResource"), E_FAIL );
m_pResourceBuffer = new CHAR[ dwSize ];
memcpy( m_pResourceBuffer, pvRes, dwSize );
MMIOINFO mmioInfo;
ZeroMemory( &mmioInfo, sizeof(mmioInfo) );
mmioInfo.fccIOProc = FOURCC_MEM;
mmioInfo.cchBuffer = dwSize;
mmioInfo.pchBuffer = (CHAR*) m_pResourceBuffer;
m_hmmio = mmioOpen( NULL, &mmioInfo, MMIO_ALLOCBUF | MMIO_READ );
}
if( FAILED( hr = ReadMMIO() ) )
{
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR_NOMSGBOX( TEXT("ReadMMIO"), hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( TEXT("ResetFile"), hr );
m_dwSize = m_ck.cksize;
}
else
{
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
MMIO_READWRITE |
MMIO_CREATE );
if( NULL == m_hmmio )
return DXTRACE_ERR( TEXT("mmioOpen"), E_FAIL );
if( FAILED( hr = WriteMMIO( &m_pwfx ) ) )
{
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR( TEXT("WriteMMIO"), hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( TEXT("ResetFile"), hr );
}
return hr;
}
HRESULT CWaveFile::OpenFromMemory( BYTE* pbData, ULONG ulDataSize,
WAVEFORMATEX* pwfx, DWORD dwFlags )
{
m_ulDataSize = ulDataSize;
m_pbData = pbData;
m_pbDataCur = m_pbData;
m_bIsReadingFromMemory = TRUE;
if( dwFlags != WAVEFILE_READ )
return E_NOTIMPL;
return S_OK;
}
HRESULT CWaveFile::ReadMMIO()
{
MMCKINFO ckIn;
PCMWAVEFORMAT pcmWaveFormat;
if( ( 0 != mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) ) )
return DXTRACE_ERR( TEXT("mmioDescend"), E_FAIL );
if( (m_ckRiff.ckid != FOURCC_RIFF) ||
(m_ckRiff.fccType != mmioFOURCC('W', 'A', 'V', 'E') ) )
return DXTRACE_ERR_NOMSGBOX( TEXT("mmioFOURCC"), E_FAIL );
ckIn.ckid = mmioFOURCC('f', 'm', 't', ' ');
if( 0 != mmioDescend( m_hmmio, &ckIn, &m_ckRiff, MMIO_FINDCHUNK ) )
return DXTRACE_ERR( TEXT("mmioDescend"), E_FAIL );
if( ckIn.cksize < (LONG) sizeof(PCMWAVEFORMAT) )
return DXTRACE_ERR( TEXT("sizeof(PCMWAVEFORMAT)"), E_FAIL );
if( mmioRead( m_hmmio, (HPSTR) &pcmWaveFormat,
sizeof(pcmWaveFormat)) != sizeof(pcmWaveFormat) )
return DXTRACE_ERR( TEXT("mmioRead"), E_FAIL );
if( pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM )
{
memcpy( &m_pwfx, &pcmWaveFormat, sizeof(pcmWaveFormat) );
m_pwfx.cbSize = 0;
}
else
return E_FAIL;
if( 0 != mmioAscend( m_hmmio, &ckIn, 0 ) )
{
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
}
return S_OK;
}
DWORD CWaveFile::GetSize()
{
return m_dwSize;
}
HRESULT CWaveFile::ResetFile()
{
if( m_bIsReadingFromMemory )
{
m_pbDataCur = m_pbData;
}
else
{
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( m_dwFlags == WAVEFILE_READ )
{
if( -1 == mmioSeek( m_hmmio, m_ckRiff.dwDataOffset + sizeof(FOURCC),
SEEK_SET ) )
return DXTRACE_ERR( TEXT("mmioSeek"), E_FAIL );
m_ck.ckid = mmioFOURCC('d', 'a', 't', 'a');
if( 0 != mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
return DXTRACE_ERR( TEXT("mmioDescend"), E_FAIL );
}
else
{
m_ck.ckid = mmioFOURCC('d', 'a', 't', 'a');
m_ck.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( TEXT("mmioCreateChunk"), E_FAIL );
if( 0 != mmioGetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
return DXTRACE_ERR( TEXT("mmioGetInfo"), E_FAIL );
}
}
return S_OK;
}
HRESULT CWaveFile::Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead )
{
if( m_bIsReadingFromMemory )
{
if( m_pbDataCur == NULL )
return CO_E_NOTINITIALIZED;
if( pdwSizeRead != NULL )
*pdwSizeRead = 0;
if( (BYTE*)(m_pbDataCur + dwSizeToRead) >
(BYTE*)(m_pbData + m_ulDataSize) )
{
dwSizeToRead = m_ulDataSize - (DWORD)(m_pbDataCur - m_pbData);
}
CopyMemory( pBuffer, m_pbDataCur, dwSizeToRead );
if( pdwSizeRead != NULL )
*pdwSizeRead = dwSizeToRead;
return S_OK;
}
else
{
MMIOINFO mmioinfoIn;
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( pBuffer == NULL || pdwSizeRead == NULL )
return E_INVALIDARG;
if( pdwSizeRead != NULL )
*pdwSizeRead = 0;
if( 0 != mmioGetInfo( m_hmmio, &mmioinfoIn, 0 ) )
return DXTRACE_ERR( TEXT("mmioGetInfo"), E_FAIL );
UINT cbDataIn = dwSizeToRead;
if( cbDataIn > m_ck.cksize )
cbDataIn = m_ck.cksize;
m_ck.cksize -= cbDataIn;
for( DWORD cT = 0; cT < cbDataIn; cT++ )
{
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
{
if( 0 != mmioAdvance( m_hmmio, &mmioinfoIn, MMIO_READ ) )
return DXTRACE_ERR( TEXT("mmioAdvance"), E_FAIL );
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
return DXTRACE_ERR( TEXT("mmioinfoIn.pchNext"), E_FAIL );
}
*((BYTE*)pBuffer+cT) = *((BYTE*)mmioinfoIn.pchNext);
mmioinfoIn.pchNext++;
}
if( 0 != mmioSetInfo( m_hmmio, &mmioinfoIn, 0 ) )
return DXTRACE_ERR( TEXT("mmioSetInfo"), E_FAIL );
if( pdwSizeRead != NULL )
*pdwSizeRead = cbDataIn;
return S_OK;
}
}
HRESULT CWaveFile::Close()
{
if( m_dwFlags == WAVEFILE_READ )
{
mmioClose( m_hmmio, 0 );
m_hmmio = NULL;
SAFE_DELETE_ARRAY( m_pResourceBuffer );
}
else
{
m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( 0 != mmioSetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
return DXTRACE_ERR( TEXT("mmioSetInfo"), E_FAIL );
if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
mmioSeek( m_hmmio, 0, SEEK_SET );
if( 0 != (INT)mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) )
return DXTRACE_ERR( TEXT("mmioDescend"), E_FAIL );
m_ck.ckid = mmioFOURCC('f', 'a', 'c', 't');
if( 0 == mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
{
DWORD dwSamples = 0;
mmioWrite( m_hmmio, (HPSTR)&dwSamples, sizeof(DWORD) );
mmioAscend( m_hmmio, &m_ck, 0 );
}
if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
mmioClose( m_hmmio, 0 );
m_hmmio = NULL;
}
return S_OK;
}
HRESULT CWaveFile::WriteMMIO( WAVEFORMATEX *pwfxDest )
{
DWORD dwFactChunk;
MMCKINFO ckOut1;
dwFactChunk = (DWORD)-1;
m_ckRiff.fccType = mmioFOURCC('W', 'A', 'V', 'E');
m_ckRiff.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &m_ckRiff, MMIO_CREATERIFF ) )
return DXTRACE_ERR( TEXT("mmioCreateChunk"), E_FAIL );
m_ck.ckid = mmioFOURCC('f', 'm', 't', ' ');
m_ck.cksize = sizeof(PCMWAVEFORMAT);
if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( TEXT("mmioCreateChunk"), E_FAIL );
if( pwfxDest->wFormatTag == WAVE_FORMAT_PCM )
{
if( mmioWrite( m_hmmio, (HPSTR) pwfxDest,
sizeof(PCMWAVEFORMAT)) != sizeof(PCMWAVEFORMAT))
return DXTRACE_ERR( TEXT("mmioWrite"), E_FAIL );
}
else
{
if( (UINT)mmioWrite( m_hmmio, (HPSTR) pwfxDest,
sizeof(*pwfxDest) + pwfxDest->cbSize ) !=
( sizeof(*pwfxDest) + pwfxDest->cbSize ) )
return DXTRACE_ERR( TEXT("mmioWrite"), E_FAIL );
}
if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
ckOut1.ckid = mmioFOURCC('f', 'a', 'c', 't');
ckOut1.cksize = 0;
if( 0 != mmioCreateChunk( m_hmmio, &ckOut1, 0 ) )
return DXTRACE_ERR( TEXT("mmioCreateChunk"), E_FAIL );
if( mmioWrite( m_hmmio, (HPSTR)&dwFactChunk, sizeof(dwFactChunk)) !=
sizeof(dwFactChunk) )
return DXTRACE_ERR( TEXT("mmioWrite"), E_FAIL );
if( 0 != mmioAscend( m_hmmio, &ckOut1, 0 ) )
return DXTRACE_ERR( TEXT("mmioAscend"), E_FAIL );
return S_OK;
}
HRESULT CWaveFile::Write( UINT nSizeToWrite, BYTE* pbSrcData, UINT* pnSizeWrote )
{
UINT cT;
if( m_bIsReadingFromMemory )
return E_NOTIMPL;
if( m_hmmio == NULL )
return CO_E_NOTINITIALIZED;
if( pnSizeWrote == NULL || pbSrcData == NULL )
return E_INVALIDARG;
*pnSizeWrote = 0;
for( cT = 0; cT < nSizeToWrite; cT++ )
{
if( m_mmioinfoOut.pchNext == m_mmioinfoOut.pchEndWrite )
{
m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
if( 0 != mmioAdvance( m_hmmio, &m_mmioinfoOut, MMIO_WRITE ) )
return DXTRACE_ERR( TEXT("mmioAdvance"), E_FAIL );
}
*((BYTE*)m_mmioinfoOut.pchNext) = *((BYTE*)pbSrcData+cT);
(BYTE*)m_mmioinfoOut.pchNext++;
(*pnSizeWrote)++;
}
return S_OK;
}
| C++ |
#ifndef DMUTIL_H
#define DMUTIL_H
#include <dmusicc.h>
#include <dmusici.h>
#include <dsound.h>
class CMusicManager;
class CMusicSegment;
class CMusicScript;
class CMusicManager
{
protected:
BOOL m_bCleanupCOM;
IDirectMusicLoader8* m_pLoader;
IDirectMusicPerformance8* m_pPerformance;
public:
CMusicManager();
~CMusicManager();
inline IDirectMusicLoader8* GetLoader() { return m_pLoader; }
inline IDirectMusicPerformance8* GetPerformance() { return m_pPerformance; }
IDirectMusicAudioPath8* GetDefaultAudioPath();
HRESULT Initialize( HWND hWnd, DWORD dwPChannels = 128, DWORD dwDefaultPathType = DMUS_APATH_DYNAMIC_STEREO );
HRESULT SetSearchDirectory( const TCHAR* strMediaPath );
VOID CollectGarbage();
HRESULT CreateSegmentFromFile( CMusicSegment** ppSegment, TCHAR* strFileName,
BOOL bDownloadNow = TRUE, BOOL bIsMidiFile = FALSE );
HRESULT CreateScriptFromFile( CMusicScript** ppScript, TCHAR* strFileName );
HRESULT CreateChordMapFromFile( IDirectMusicChordMap8** ppChordMap, TCHAR* strFileName );
HRESULT CreateStyleFromFile( IDirectMusicStyle8** ppStyle, TCHAR* strFileName );
HRESULT GetMotifFromStyle( IDirectMusicSegment8** ppMotif, TCHAR* strStyle, TCHAR* wstrMotif );
HRESULT CreateSegmentFromResource( CMusicSegment** ppSegment, TCHAR* strResource, TCHAR* strResourceType,
BOOL bDownloadNow = TRUE, BOOL bIsMidiFile = FALSE );
};
class CMusicSegment
{
protected:
IDirectMusicSegment8* m_pSegment;
IDirectMusicLoader8* m_pLoader;
IDirectMusicPerformance8* m_pPerformance;
IDirectMusicAudioPath8* m_pEmbeddedAudioPath;
BOOL m_bDownloaded;
public:
CMusicSegment( IDirectMusicPerformance8* pPerformance,
IDirectMusicLoader8* pLoader,
IDirectMusicSegment8* pSegment );
virtual ~CMusicSegment();
inline IDirectMusicSegment8* GetSegment() { return m_pSegment; }
HRESULT GetStyle( IDirectMusicStyle8** ppStyle, DWORD dwStyleIndex = 0 );
HRESULT SetRepeats( DWORD dwRepeats );
HRESULT Play( DWORD dwFlags = DMUS_SEGF_SECONDARY, IDirectMusicAudioPath8* pAudioPath = NULL );
HRESULT Stop( DWORD dwFlags = 0 );
HRESULT Download( IDirectMusicAudioPath8* pAudioPath = NULL );
HRESULT Unload( IDirectMusicAudioPath8* pAudioPath = NULL );
BOOL IsPlaying();
};
class CMusicScript
{
protected:
IDirectMusicScript8* m_pScript;
IDirectMusicLoader8* m_pLoader;
IDirectMusicPerformance8* m_pPerformance;
public:
CMusicScript( IDirectMusicPerformance8* pPerformance,
IDirectMusicLoader8* pLoader,
IDirectMusicScript8* pScript );
virtual ~CMusicScript();
inline IDirectMusicScript8* GetScript() { return m_pScript; }
HRESULT CallRoutine( TCHAR* strRoutine );
HRESULT SetVariableNumber( TCHAR* strVariable, LONG lValue );
HRESULT GetVariableNumber( TCHAR* strVariable, LONG* plValue );
};
#endif
| C++ |
#ifndef D3DFONT_H
#define D3DFONT_H
#include <tchar.h>
#include <D3D8.h>
#define D3DFONT_BOLD 0x0001
#define D3DFONT_ITALIC 0x0002
#define D3DFONT_ZENABLE 0x0004
#define D3DFONT_CENTERED 0x0001
#define D3DFONT_TWOSIDED 0x0002
#define D3DFONT_FILTERED 0x0004
class CD3DFont
{
TCHAR m_strFontName[80];
DWORD m_dwFontHeight;
DWORD m_dwFontFlags;
LPDIRECT3DDEVICE8 m_pd3dDevice;
LPDIRECT3DTEXTURE8 m_pTexture;
LPDIRECT3DVERTEXBUFFER8 m_pVB;
DWORD m_dwTexWidth;
DWORD m_dwTexHeight;
FLOAT m_fTextScale;
FLOAT m_fTexCoords[128-32][4];
DWORD m_dwSavedStateBlock;
DWORD m_dwDrawTextStateBlock;
public:
HRESULT CD3DFont::DrawTexture( FLOAT sx, FLOAT sy, DWORD dwColor, DWORD dwFlags );
void CD3DFont::SetRenderState();
HRESULT DrawText( FLOAT x, FLOAT y, DWORD dwColor,
TCHAR* strText, DWORD dwFlags=0L );
HRESULT DrawTextScaled( FLOAT x, FLOAT y, FLOAT z,
FLOAT fXScale, FLOAT fYScale, DWORD dwColor,
TCHAR* strText, DWORD dwFlags=0L );
HRESULT Render3DText( TCHAR* strText, DWORD dwFlags=0L );
HRESULT GetTextExtent( TCHAR* strText, SIZE* pSize );
HRESULT InitDeviceObjects( LPDIRECT3DDEVICE8 pd3dDevice );
HRESULT RestoreDeviceObjects();
HRESULT InvalidateDeviceObjects();
HRESULT DeleteDeviceObjects();
CD3DFont( TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags=0L );
~CD3DFont();
};
#endif
| C++ |
#ifndef DSUTIL_H
#define DSUTIL_H
#include <windows.h>
#include <mmsystem.h>
#include <mmreg.h>
#include <dsound.h>
class CSoundManager;
class CSound;
class CStreamingSound;
class CWaveFile;
#define WAVEFILE_READ 1
#define WAVEFILE_WRITE 2
#define DSUtil_StopSound(s) { if(s) s->Stop(); }
#define DSUtil_PlaySound(s) { if(s) s->Play( 0, 0 ); }
#define DSUtil_PlaySoundLooping(s) { if(s) s->Play( 0, DSBPLAY_LOOPING ); }
class CSoundManager
{
public:
LPDIRECTSOUND8 m_pDS;
public:
CSoundManager();
~CSoundManager();
HRESULT Initialize( HWND hWnd, DWORD dwCoopLevel, DWORD dwPrimaryChannels, DWORD dwPrimaryFreq, DWORD dwPrimaryBitRate );
inline LPDIRECTSOUND8 GetDirectSound() { return m_pDS; }
HRESULT SetPrimaryBufferFormat( DWORD dwPrimaryChannels, DWORD dwPrimaryFreq, DWORD dwPrimaryBitRate );
HRESULT Get3DListenerInterface( LPDIRECTSOUND3DLISTENER* ppDSListener );
HRESULT Create( CSound* pSound, LPTSTR strWaveFileName, DWORD dwCreationFlags = 0, GUID guid3DAlgorithm = GUID_NULL );
};
class CSound
{
public:
LPDIRECTSOUNDBUFFER m_apDSBuffer;
DWORD m_dwDSBufferSize;
LPDIRECTSOUND3DBUFFER m_pDS3DBuffer;
CWaveFile *m_pWaveFile;
protected:
HRESULT RestoreBuffer( LPDIRECTSOUNDBUFFER pDSB, BOOL* pbWasRestored );
public:
CSound();
virtual ~CSound();
void Release();
HRESULT Create( DWORD dwDSBufferSize, CWaveFile* pWaveFile );
HRESULT Get3DBufferInterface( LPDIRECTSOUND3DBUFFER* ppDS3DBuffer );
HRESULT FillBufferWithSound( LPDIRECTSOUNDBUFFER pDSB, int bRepeatWavIfBufferLarger , DWORD sizeBuffer );
LPDIRECTSOUND3DBUFFER Get3DBuffer() { return m_pDS3DBuffer; }
HRESULT Play( LPDIRECTSOUNDBUFFER pDSB, DWORD sizeBuffer, DWORD dwPriority = 0, DWORD dwFlags = 0 );
HRESULT Stop( LPDIRECTSOUNDBUFFER pDSB );
HRESULT Reset( LPDIRECTSOUNDBUFFER pDSB );
int IsSoundPlaying( LPDIRECTSOUNDBUFFER pDSB );
};
class CWaveFile
{
public:
WAVEFORMATEX m_pwfx;
HMMIO m_hmmio;
MMCKINFO m_ck;
MMCKINFO m_ckRiff;
DWORD m_dwSize;
MMIOINFO m_mmioinfoOut;
DWORD m_dwFlags;
int m_bIsReadingFromMemory;
BYTE* m_pbData;
BYTE* m_pbDataCur;
ULONG m_ulDataSize;
CHAR* m_pResourceBuffer;
protected:
HRESULT ReadMMIO();
HRESULT WriteMMIO( WAVEFORMATEX *pwfxDest );
public:
CWaveFile();
~CWaveFile();
HRESULT Open( LPTSTR strFileName, DWORD dwFlags );
HRESULT OpenFromMemory( BYTE* pbData, ULONG ulDataSize, WAVEFORMATEX* pwfx, DWORD dwFlags );
HRESULT Close();
HRESULT Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead );
HRESULT Write( UINT nSizeToWrite, BYTE* pbData, UINT* pnSizeWrote );
DWORD GetSize();
HRESULT ResetFile();
WAVEFORMATEX* GetFormat() { return &m_pwfx; };
};
#endif
| C++ |
#define STRICT
#include <windows.h>
#include <mmsystem.h>
#include <tchar.h>
#include <stdio.h>
#include <stdarg.h>
#include "DXUtil.h"
const TCHAR* DXUtil_GetDXSDKMediaPath()
{
static TCHAR strNull[2] = _T("");
static TCHAR strPath[MAX_PATH];
DWORD dwType;
DWORD dwSize = MAX_PATH;
HKEY hKey;
LONG lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
_T("Software\\Microsoft\\DirectX SDK"),
0, KEY_READ, &hKey );
if( ERROR_SUCCESS != lResult )
return strNull;
lResult = RegQueryValueEx( hKey, _T("DX81SDK Samples Path"), NULL,
&dwType, (BYTE*)strPath, &dwSize );
RegCloseKey( hKey );
if( ERROR_SUCCESS != lResult )
return strNull;
_tcscat( strPath, _T("\\Media\\") );
return strPath;
}
HRESULT DXUtil_FindMediaFile( TCHAR* strPath, TCHAR* strFilename )
{
HANDLE file;
TCHAR strFullPath[1024];
TCHAR *strShortName;
DWORD cchPath;
if( NULL==strFilename || NULL==strPath )
return E_INVALIDARG;
cchPath = GetFullPathName(strFilename, sizeof(strFullPath)/sizeof(TCHAR), strFullPath, &strShortName);
if ((cchPath == 0) || (sizeof(strFullPath)/sizeof(TCHAR) <= cchPath))
return E_FAIL;
file = CreateFile( strFullPath, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL );
if( INVALID_HANDLE_VALUE != file )
{
_tcscpy( strPath, strFullPath );
CloseHandle( file );
return S_OK;
}
file = CreateFile( strShortName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL );
if( INVALID_HANDLE_VALUE != file )
{
_tcscpy( strPath, strShortName );
CloseHandle( file );
return S_OK;
}
_stprintf( strPath, _T("%s%s"), DXUtil_GetDXSDKMediaPath(), strShortName );
file = CreateFile( strPath, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, NULL );
if( INVALID_HANDLE_VALUE != file )
{
CloseHandle( file );
return S_OK;
}
_tcscpy( strPath, strFilename );
return E_FAIL;
}
HRESULT DXUtil_ReadStringRegKey( HKEY hKey, TCHAR* strRegName, TCHAR* strValue,
DWORD dwLength, TCHAR* strDefault )
{
DWORD dwType;
if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
(BYTE*)strValue, &dwLength ) )
{
_tcscpy( strValue, strDefault );
}
return S_OK;
}
HRESULT DXUtil_WriteStringRegKey( HKEY hKey, TCHAR* strRegName,
TCHAR* strValue )
{
if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_SZ,
(BYTE*)strValue,
(_tcslen(strValue)+1)*sizeof(TCHAR) ) )
return E_FAIL;
return S_OK;
}
HRESULT DXUtil_ReadIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD* pdwValue,
DWORD dwDefault )
{
DWORD dwType;
DWORD dwLength = sizeof(DWORD);
if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
(BYTE*)pdwValue, &dwLength ) )
{
*pdwValue = dwDefault;
}
return S_OK;
}
HRESULT DXUtil_WriteIntRegKey( HKEY hKey, TCHAR* strRegName, DWORD dwValue )
{
if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,
(BYTE*)&dwValue, sizeof(DWORD) ) )
return E_FAIL;
return S_OK;
}
HRESULT DXUtil_ReadBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL* pbValue,
BOOL bDefault )
{
DWORD dwType;
DWORD dwLength = sizeof(BOOL);
if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
(BYTE*)pbValue, &dwLength ) )
{
*pbValue = bDefault;
}
return S_OK;
}
HRESULT DXUtil_WriteBoolRegKey( HKEY hKey, TCHAR* strRegName, BOOL bValue )
{
if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_DWORD,
(BYTE*)&bValue, sizeof(BOOL) ) )
return E_FAIL;
return S_OK;
}
HRESULT DXUtil_ReadGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID* pGuidValue,
GUID& guidDefault )
{
DWORD dwType;
DWORD dwLength = sizeof(GUID);
if( ERROR_SUCCESS != RegQueryValueEx( hKey, strRegName, 0, &dwType,
(LPBYTE) pGuidValue, &dwLength ) )
{
*pGuidValue = guidDefault;
}
return S_OK;
}
HRESULT DXUtil_WriteGuidRegKey( HKEY hKey, TCHAR* strRegName, GUID guidValue )
{
if( ERROR_SUCCESS != RegSetValueEx( hKey, strRegName, 0, REG_BINARY,
(BYTE*)&guidValue, sizeof(GUID) ) )
return E_FAIL;
return S_OK;
}
FLOAT __stdcall DXUtil_Timer( TIMER_COMMAND command )
{
static BOOL m_bTimerInitialized = FALSE;
static BOOL m_bUsingQPF = FALSE;
static BOOL m_bTimerStopped = TRUE;
static LONGLONG m_llQPFTicksPerSec = 0;
if( FALSE == m_bTimerInitialized )
{
m_bTimerInitialized = TRUE;
LARGE_INTEGER qwTicksPerSec;
m_bUsingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
if( m_bUsingQPF )
m_llQPFTicksPerSec = qwTicksPerSec.QuadPart;
}
if( m_bUsingQPF )
{
static LONGLONG m_llStopTime = 0;
static LONGLONG m_llLastElapsedTime = 0;
static LONGLONG m_llBaseTime = 0;
double fTime;
double fElapsedTime;
LARGE_INTEGER qwTime;
if( m_llStopTime != 0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
qwTime.QuadPart = m_llStopTime;
else
QueryPerformanceCounter( &qwTime );
if( command == TIMER_GETELAPSEDTIME )
{
fElapsedTime = (double) ( qwTime.QuadPart - m_llLastElapsedTime ) / (double) m_llQPFTicksPerSec;
m_llLastElapsedTime = qwTime.QuadPart;
return (FLOAT) fElapsedTime;
}
if( command == TIMER_GETAPPTIME )
{
double fAppTime = (double) ( qwTime.QuadPart - m_llBaseTime ) / (double) m_llQPFTicksPerSec;
return (FLOAT) fAppTime;
}
if( command == TIMER_RESET )
{
m_llBaseTime = qwTime.QuadPart;
m_llLastElapsedTime = qwTime.QuadPart;
m_llStopTime = 0;
m_bTimerStopped = FALSE;
return 0.0f;
}
if( command == TIMER_START )
{
if( m_bTimerStopped )
m_llBaseTime += qwTime.QuadPart - m_llStopTime;
m_llStopTime = 0;
m_llLastElapsedTime = qwTime.QuadPart;
m_bTimerStopped = FALSE;
return 0.0f;
}
if( command == TIMER_STOP )
{
m_llStopTime = qwTime.QuadPart;
m_llLastElapsedTime = qwTime.QuadPart;
m_bTimerStopped = TRUE;
return 0.0f;
}
if( command == TIMER_ADVANCE )
{
m_llStopTime += m_llQPFTicksPerSec/10;
return 0.0f;
}
if( command == TIMER_GETABSOLUTETIME )
{
fTime = qwTime.QuadPart / (double) m_llQPFTicksPerSec;
return (FLOAT) fTime;
}
return -1.0f;
}
else
{
static double m_fLastElapsedTime = 0.0;
static double m_fBaseTime = 0.0;
static double m_fStopTime = 0.0;
double fTime;
double fElapsedTime;
if( m_fStopTime != 0.0 && command != TIMER_START && command != TIMER_GETABSOLUTETIME)
fTime = m_fStopTime;
else
fTime = timeGetTime() * 0.001;
if( command == TIMER_GETELAPSEDTIME )
{
fElapsedTime = (double) (fTime - m_fLastElapsedTime);
m_fLastElapsedTime = fTime;
return (FLOAT) fElapsedTime;
}
if( command == TIMER_GETAPPTIME )
{
return (FLOAT) (fTime - m_fBaseTime);
}
if( command == TIMER_RESET )
{
m_fBaseTime = fTime;
m_fLastElapsedTime = fTime;
m_fStopTime = 0;
m_bTimerStopped = FALSE;
return 0.0f;
}
if( command == TIMER_START )
{
if( m_bTimerStopped )
m_fBaseTime += fTime - m_fStopTime;
m_fStopTime = 0.0f;
m_fLastElapsedTime = fTime;
m_bTimerStopped = FALSE;
return 0.0f;
}
if( command == TIMER_STOP )
{
m_fStopTime = fTime;
m_fLastElapsedTime = fTime;
m_bTimerStopped = TRUE;
return 0.0f;
}
if( command == TIMER_ADVANCE )
{
m_fStopTime += 0.1f;
return 0.0f;
}
if( command == TIMER_GETABSOLUTETIME )
{
return (FLOAT) fTime;
}
return -1.0f;
}
}
VOID DXUtil_ConvertAnsiStringToWide( WCHAR* wstrDestination, const CHAR* strSource,
int cchDestChar )
{
if( wstrDestination==NULL || strSource==NULL )
return;
if( cchDestChar == -1 )
cchDestChar = strlen(strSource)+1;
MultiByteToWideChar( CP_ACP, 0, strSource, -1,
wstrDestination, cchDestChar-1 );
wstrDestination[cchDestChar-1] = 0;
}
VOID DXUtil_ConvertWideStringToAnsi( CHAR* strDestination, const WCHAR* wstrSource,
int cchDestChar )
{
if( strDestination==NULL || wstrSource==NULL )
return;
if( cchDestChar == -1 )
cchDestChar = wcslen(wstrSource)+1;
WideCharToMultiByte( CP_ACP, 0, wstrSource, -1, strDestination,
cchDestChar-1, NULL, NULL );
strDestination[cchDestChar-1] = 0;
}
VOID DXUtil_ConvertGenericStringToAnsi( CHAR* strDestination, const TCHAR* tstrSource,
int cchDestChar )
{
if( strDestination==NULL || tstrSource==NULL || cchDestChar == 0 )
return;
#ifdef _UNICODE
DXUtil_ConvertWideStringToAnsi( strDestination, tstrSource, cchDestChar );
#else
if( cchDestChar == -1 )
{
strcpy( strDestination, tstrSource );
}
else
{
strncpy( strDestination, tstrSource, cchDestChar );
strDestination[cchDestChar-1] = '\0';
}
#endif
}
VOID DXUtil_ConvertGenericStringToWide( WCHAR* wstrDestination, const TCHAR* tstrSource,
int cchDestChar )
{
if( wstrDestination==NULL || tstrSource==NULL || cchDestChar == 0 )
return;
#ifdef _UNICODE
if( cchDestChar == -1 )
{
wcscpy( wstrDestination, tstrSource );
}
else
{
wcsncpy( wstrDestination, tstrSource, cchDestChar );
wstrDestination[cchDestChar-1] = L'\0';
}
#else
DXUtil_ConvertAnsiStringToWide( wstrDestination, tstrSource, cchDestChar );
#endif
}
VOID DXUtil_ConvertAnsiStringToGeneric( TCHAR* tstrDestination, const CHAR* strSource,
int cchDestChar )
{
if( tstrDestination==NULL || strSource==NULL || cchDestChar == 0 )
return;
#ifdef _UNICODE
DXUtil_ConvertAnsiStringToWide( tstrDestination, strSource, cchDestChar );
#else
if( cchDestChar == -1 )
{
strcpy( tstrDestination, strSource );
}
else
{
strncpy( tstrDestination, strSource, cchDestChar );
tstrDestination[cchDestChar-1] = '\0';
}
#endif
}
VOID DXUtil_ConvertWideStringToGeneric( TCHAR* tstrDestination, const WCHAR* wstrSource,
int cchDestChar )
{
if( tstrDestination==NULL || wstrSource==NULL || cchDestChar == 0 )
return;
#ifdef _UNICODE
if( cchDestChar == -1 )
{
wcscpy( tstrDestination, wstrSource );
}
else
{
wcsncpy( tstrDestination, wstrSource, cchDestChar );
tstrDestination[cchDestChar-1] = L'\0';
}
#else
DXUtil_ConvertWideStringToAnsi( tstrDestination, wstrSource, cchDestChar );
#endif
}
HRESULT _DbgOut( TCHAR* strFile, DWORD dwLine, HRESULT hr, TCHAR* strMsg )
{
TCHAR buffer[256];
wsprintf( buffer, _T("%s(%ld): "), strFile, dwLine );
OutputDebugString( buffer );
OutputDebugString( strMsg );
if( hr )
{
wsprintf( buffer, _T("(hr=%08lx)\n"), hr );
OutputDebugString( buffer );
}
OutputDebugString( _T("\n") );
return hr;
}
VOID DXUtil_Trace( TCHAR* strMsg, ... )
{
#if defined(DEBUG) | defined(_DEBUG)
TCHAR strBuffer[512];
va_list args;
va_start(args, strMsg);
_vsntprintf( strBuffer, 512, strMsg, args );
va_end(args);
OutputDebugString( strBuffer );
#else
UNREFERENCED_PARAMETER(strMsg);
#endif
}
BOOL DXUtil_ConvertStringToGUID( const TCHAR* strIn, GUID* pGuidOut )
{
UINT aiTmp[10];
if( _stscanf( strIn, TEXT("{%8X-%4X-%4X-%2X%2X-%2X%2X%2X%2X%2X%2X}"),
&pGuidOut->Data1,
&aiTmp[0], &aiTmp[1],
&aiTmp[2], &aiTmp[3],
&aiTmp[4], &aiTmp[5],
&aiTmp[6], &aiTmp[7],
&aiTmp[8], &aiTmp[9] ) != 11 )
{
ZeroMemory( pGuidOut, sizeof(GUID) );
return FALSE;
}
else
{
pGuidOut->Data2 = (USHORT) aiTmp[0];
pGuidOut->Data3 = (USHORT) aiTmp[1];
pGuidOut->Data4[0] = (BYTE) aiTmp[2];
pGuidOut->Data4[1] = (BYTE) aiTmp[3];
pGuidOut->Data4[2] = (BYTE) aiTmp[4];
pGuidOut->Data4[3] = (BYTE) aiTmp[5];
pGuidOut->Data4[4] = (BYTE) aiTmp[6];
pGuidOut->Data4[5] = (BYTE) aiTmp[7];
pGuidOut->Data4[6] = (BYTE) aiTmp[8];
pGuidOut->Data4[7] = (BYTE) aiTmp[9];
return TRUE;
}
}
VOID DXUtil_ConvertGUIDToString( const GUID* pGuidIn, TCHAR* strOut )
{
_stprintf( strOut, TEXT("{%0.8X-%0.4X-%0.4X-%0.2X%0.2X-%0.2X%0.2X%0.2X%0.2X%0.2X%0.2X}"),
pGuidIn->Data1, pGuidIn->Data2, pGuidIn->Data3,
pGuidIn->Data4[0], pGuidIn->Data4[1],
pGuidIn->Data4[2], pGuidIn->Data4[3],
pGuidIn->Data4[4], pGuidIn->Data4[5],
pGuidIn->Data4[6], pGuidIn->Data4[7] );
}
| C++ |
#include "global_def.h"
CGameTarget g_GameTarget;
CGameTarget::CGameTarget()
{
}
CGameTarget::~CGameTarget()
{
}
float CGameTarget::GTH_GetTargetDistance( Fx_CHARACTER_t *pThisChar )
{
Fx_CHARACTER_t* character;
int i;
float dist;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( -1.0f );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters ) return( -1.0f);
dist = GTH_GetDistance2D( pThisChar->position, character->position );
if(dist <0.0f)
{
DXUtil_Trace("- dist %2.f \n",dist);
}
return( dist );
}
int CGameTarget::GTH_GetTargetPosition( int targetType, int targetIdx, vec3_t position )
{
Fx_CHARACTER_t* character;
int i;
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == targetType && \
character->idxOnServer == targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( 0 );
}
VectorCopy( position, character->position );
position[2] += 50.0f;
return( 1 );
}
int CGameTarget::GTH_GetTargetPosition( Fx_CHARACTER_t* pThisChar, vec3_t pos )
{
Fx_CHARACTER_t* character;
int i;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( 0 );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters ) return( 0 );
VectorCopy( pos, character->position );
return( 1 );
}
int CGameTarget::GTH_GetTargetAlive( Fx_CHARACTER_t* pThisChar )
{
Fx_CHARACTER_t* character;
int i;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( 0 );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( 0 );
}
if( character->curRA <= 0 )
{
return( 0 );
}
return( 1 );
}
int CGameTarget::GTH_GetTargetClientID( Fx_CHARACTER_t* pThisChar )
{
Fx_CHARACTER_t* character;
int i;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( -1 );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( -1 );
}
return( character->ID );
}
int CGameTarget::GTH_SetAngleToTarget( Fx_CHARACTER_t* pThisChar )
{
Fx_CHARACTER_t* character;
int i;
vec3_t dir, angles;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( 0 );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( 0 );
}
VectorSubtract( dir, character->position, pThisChar->position );
dir[2] = 0.0f;
VectorNormalize( dir );
VectorToAngles( dir , angles );
pThisChar->angles[ YAW ] = angles[ YAW ];
return( 1 );
}
Fx_CHARACTER_t* CGameTarget::GTH_GetTargetPointer( Fx_CHARACTER_t* pThisChar )
{
Fx_CHARACTER_t* character;
int i;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( NULL );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( NULL );
}
return( character );
}
Fx_CHARACTER_t* CGameTarget::GTH_GetTargetPointer( int targetType, int targetIdx )
{
Fx_CHARACTER_t* character;
int i;
if( targetType < 0 || targetIdx < 0 ) return( NULL );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == targetType && \
character->idxOnServer == targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( NULL );
}
return( character );
}
void CGameTarget::GTH_ChangeTarget( Fx_CHARACTER_t *character )
{
g_pApp->m_myCharacter->atk_playAnim = false;
g_pApp->m_myCharacter->targetType = character->entityType;
g_pApp->m_myCharacter->targetIdx = character->idxOnServer;
g_cgv.myCharacterInfo->targetType = character->entityType;
g_cgv.myCharacterInfo->targetIdx = character->idxOnServer;
g_cgv.pTargetChar = character;
strcpy( g_cgv.targetName, character->name );
g_cgv.resendTargeting = false;
g_cgv.resendTime = g_timer.GetAppMilliTime() - TARGETING_RESEND_DELAY;
g_cgv.resendAttack = false;
VectorClear( g_cgv.oldTargetPosition );
g_cgv.saveEvent = -1;
g_cgv.clickEvent = GTH_CEV_CHAR_IDLE;
}
int CGameTarget::GTH_GetTargetName( int targetType, int targetIdx, char *name )
{
Fx_CHARACTER_t* character;
int i;
if( targetType < 0 || targetIdx < 0 ) return( false );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == targetType && \
character->idxOnServer == targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( false );
}
strcpy( name, character->name );
return( true );
}
int CGameTarget::GTH_GetTargetServerIdxFromName( char* name )
{
Fx_CHARACTER_t* character;
int i;
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == ENTITY_PC )
{
if( !stricmp( character->name, name ) ) break;
}
}
if( i == g_charManager->m_iNumCharacters )
{
return( -1 );
}
return( character->idxOnServer );
}
| C++ |
#include "stdafx.h"
int GetDays(tm ToDay)
{
CTime from;
from =CTime::GetCurrentTime();
CTime to(ToDay.tm_year,ToDay.tm_mon,ToDay.tm_mday,0,0,0);
CTimeSpan elapsedTime = to - from;
return elapsedTime.GetDays();
}
int GetElapsedDays (int yy,int mm,int dd)
{
CTime curr;
curr =CTime::GetCurrentTime();
CTime from(curr.GetYear(),curr.GetMonth(),curr.GetDay(),24,0,0);
CTime to(yy,mm,dd,24,0,0);
CTimeSpan elapsedTime = to - from;
return elapsedTime.GetDays();
}
| C++ |
#include "stdafx.h"
| C++ |
#include <windows.h>
#include <basetsd.h>
#include <tchar.h>
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
int GTH::LoadShaders()
{
packsearch_t *list , *tmpList;
int i , size , ret;
int success;
int numShaders;
success = 0;
numShaders = 0;
size = g_fileMng.ReadExtFilesFromPack( "shader" , &list );
tmpList = list;
for( i = 0 ; i < size ; i++ , tmpList++ )
numShaders += g_shaderMng.GetShaderCount( tmpList->name );
g_shaderMng.Init( numShaders );
for( i = 0 ; i < size ; i++ , list++ )
{
ret = g_shaderMng.ReadShaderScript( list->name );
if( !ret )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in loading shader file" );
continue;
}
success++;
}
if( !success ) return false;
success = 0;
numShaders = 0;
size = g_fileMng.ReadExtFilesFromPack( "model.shader" , &list );
tmpList = list;
for( i = 0 ; i < size ; i++ , tmpList++ )
numShaders += g_modelShaderMng->GetShaderCount( tmpList->name );
g_modelShaderMng->Init( numShaders );
for( i = 0 ; i < size ; i++ , list++ )
{
ret = g_modelShaderMng->ReadShaderScript( list->name );
if( !ret )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in loading shader file" );
continue;
}
success++;
}
if( !success ) return true;
success = 0;
numShaders = 0;
size = g_fileMng.ReadExtFilesFromPack( "character.shader" , &list );
tmpList = list;
for( i = 0 ; i < size ; i++ , tmpList++ )
numShaders += g_charShaderMng->GetShaderCount( tmpList->name );
g_charShaderMng->Init( numShaders );
for( i = 0 ; i < size ; i++ , list++ )
{
ret = g_charShaderMng->ReadShaderScript( list->name );
if( !ret )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in loading shader file" );
continue;
}
success++;
}
if( !success ) return true;
return true;
}
int GTH::LoadMap( char *pMap )
{
CBSP *world;
world = new CBSP();
if( !world )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "GTH::LoadMap::world" );
return false;
}
world->SetID( m_numWorldBSPs );
if( !world->Load( pMap ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not load world" );
return false;
}
m_worldBSPs[ m_numWorldBSPs++ ] = world;
return true;
}
int GTH::LoadMDLClasses( mapinfo_t *mapInfo )
{
CMDLMng *MDLMng;
if( m_MDLMng )
m_MDLMng->Release();
GTH_SAFE_DELETE( m_MDLMng );
MDLMng = new CMDLMng;
if( !MDLMng )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "GTH::LoadMDLClasses::MDLMng" );
return false;
}
MDLMng->SetFileMng( &g_fileMng );
MDLMng->SetRenderer( &g_d3dRender );
MDLMng->SetScript( &g_script );
MDLMng->SetShaderMng( g_modelShaderMng );
MDLMng->SetTexMng( &g_texMng );
MDLMng->SetTimer( &g_timer );
MDLMng->SetDevice( m_pd3dDevice );
MDLMng->SetMusicMng( g_musicMng );
if( !MDLMng->LoadWorldClass( mapInfo->modelName ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not load model class" );
return false;
}
if( !MDLMng->LoadItemClass( mapInfo->itemName ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not load model class" );
return false;
}
if( !MDLMng->LoadEffectClass( mapInfo->effectName ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not load model class" );
return false;
}
m_MDLMng = MDLMng;
g_charManager->SetMDLMng( m_MDLMng );
return true;
}
int GTH::LoadEntity( char *objectfName )
{
if( !g_entityMng->LoadEntity( objectfName ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not load model entity object" );
return false;
}
g_entityMng->SetMDLMng( m_MDLMng );
g_itemMng->SetMDLMng( m_MDLMng );
g_effectMng->SetMDLMng( m_MDLMng );
return true;
}
int GTH::LoadConfig( char *fname )
{
char *token;
int numBrace;
int spawnId;
int i;
int red , green , blue;
if( !g_script.Load( fname ) )
return false;
g_script.BeginParse();
memset ( m_mapInfos, 0, sizeof(m_mapInfos) );
m_numMapInfos = 0;
numBrace = 0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
if( token[0] == '{' )
{
numBrace++;
m_mapInfos[ m_numMapInfos ].worldVisible = 30000.0f;
m_mapInfos[ m_numMapInfos ].modelVisible = 10000.0f;
m_mapInfos[ m_numMapInfos ].itemVisible = 5000.0f;
m_mapInfos[ m_numMapInfos ].effectVisible = 5000.0f;
m_mapInfos[ m_numMapInfos ].numSpawnPos = 0;
m_mapInfos[ m_numMapInfos ].numSpawnAngles = 0;
VectorSet( m_mapInfos[ m_numMapInfos ].sunAngle , 1.0f , 0.5f , -0.5f );
VectorSet( m_mapInfos[ m_numMapInfos ].sunColor , 1.0f , 1.0f , 1.0f );
VectorNormalize( m_mapInfos[ m_numMapInfos ].sunAngle );
}
else if( !stricmp( token , "world" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].mapName , token );
}
else if( !stricmp( token , "model" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].modelName , token );
}
else if( !stricmp( token , "item" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].itemName , token );
}
else if( !stricmp( token , "effect" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].effectName , token );
}
else if( !stricmp( token , "object" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].objectName , token );
}
else if( !stricmp( token , "position" ) )
{
spawnId = m_mapInfos[ m_numMapInfos ].numSpawnPos;
if( spawnId >= GTH_MAX_SIZE_MAP_SPAWN_POS )
{
g_script.SkipLine();
continue;
}
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].spawnPos[ spawnId ][0] = (float)atof( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].spawnPos[ spawnId ][1] = (float)atof( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].spawnPos[ spawnId ][2] = (float)atof( token );
m_mapInfos[ m_numMapInfos ].numSpawnPos++;
}
else if( !stricmp( token , "angle" ) )
{
spawnId = m_mapInfos[ m_numMapInfos ].numSpawnAngles;
if( spawnId >= GTH_MAX_SIZE_MAP_SPAWN_POS )
{
g_script.SkipLine();
continue;
}
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].spawnAngle[ spawnId ] = (float)atof( token );
m_mapInfos[ m_numMapInfos ].numSpawnAngles++;
}
else if( !stricmp( token , "worldVisible" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].worldVisible = (float)atof( token );
}
else if( !stricmp( token , "modelVisible" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].modelVisible = (float)atof( token );
}
else if( !stricmp( token , "itemVisible" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].itemVisible = (float)atof( token );
}
else if( !stricmp( token , "effectVisible" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].effectVisible = (float)atof( token );
}
else if( !stricmp( token , "bgmusic" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
strcpy( m_mapInfos[ m_numMapInfos ].BGMusic , token );
}
else if( !stricmp( token , "sunangle" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].sunAngle[ YAW ] = (float)atof( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].sunAngle[ PITCH ] = (float)atof( token );
m_mapInfos[ m_numMapInfos ].sunAngle[ ROLL ] = 0.0f;
m_mapInfos[ m_numMapInfos ].sunAngle[ YAW ] += 180.0f;
if( m_mapInfos[ m_numMapInfos ].sunAngle[ YAW ] > 360.0f )
m_mapInfos[ m_numMapInfos ].sunAngle[ YAW ] -= 360.0f;
AngleToVector( m_mapInfos[ m_numMapInfos ].sunAngle , m_mapInfos[ m_numMapInfos ].sunAngle );
}
else if( !stricmp( token , "suncolor" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].sunColor[0] = (float)atof( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].sunColor[1] = (float)atof( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].sunColor[2] = (float)atof( token );
}
else if( !stricmp( token , "fogcolor" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
red = atoi( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
green = atoi( token );
token = g_script.GetNextToken( true );
if( !token )
return false;
blue = atoi( token );
m_mapInfos[ m_numMapInfos ].fogColor = MAKE_COLOR_ARGB( 0x00 , red , green , blue );
m_mapInfos[ m_numMapInfos ].fogColor = 0;
}
else if( !stricmp( token , "fogStart" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].fogStart = (float)atof( token );
}
else if( !stricmp( token , "fogEnd" ) )
{
token = g_script.GetNextToken( true );
if( !token )
return false;
m_mapInfos[ m_numMapInfos ].fogEnd = (float)atof( token );
}
else if ( ! stricmp ( token, "monsterKind" ) )
{
token = g_script .GetNextToken (true);
if ( ! token )
return false;
int monsterKind = (int)atoi ( token );
if ( monsterKind <= 0 )
return false;
m_mapInfos [m_numMapInfos].monsterKind = monsterKind;
for ( int index = 0; \
index < monsterKind; \
++index )
{
token = g_script .GetNextToken ( true );
if ( ! token )
return false;
m_mapInfos [m_numMapInfos].monsters [index] = atoi ( token );
}
CSkillTransformData *pTransList = g_SkillTransInfo.Get();
int size = pTransList->m_TransData.size();
for(int i=0;i<size;i++)
{
m_mapInfos [m_numMapInfos].monsters[index + i] = pTransList->m_TransData[i]->m_nTransformEntityIdx;
}
m_mapInfos [m_numMapInfos].monsterKind += size;
}
else if ( ! stricmp ( token , "weather" ) )
{
token = g_script .GetNextToken (true);
if ( ! token )
return false;
if ( ! stricmp ( token, "rain" ) )
{
m_mapInfos [m_numMapInfos].weather = TIME_RAIN;
}
else if ( ! stricmp ( token, "snow" ) )
{
m_mapInfos [m_numMapInfos].weather = TIME_SNOW;
}
else
{
m_mapInfos [m_numMapInfos].weather = TIME_DAY;
}
}
else if ( ! stricmp( token, "bgvolume" ) )
{
token = g_script.GetNextToken( true );
if ( ! token )
return false;
m_mapInfos[ m_numMapInfos ].bgVolume = atoi( token );
}
else if ( ! stricmp( token, "effectvolume" ) )
{
token = g_script.GetNextToken( true );
if ( ! token )
return false;
m_mapInfos[ m_numMapInfos ].effectVolume = atoi( token );
}
else if( token[0] == '}' )
{
if( m_mapInfos[ m_numMapInfos ].numSpawnAngles < m_mapInfos[ m_numMapInfos ].numSpawnPos )
{
for( i = m_mapInfos[ m_numMapInfos ].numSpawnAngles ; i < m_mapInfos[ m_numMapInfos ].numSpawnPos ; i++ )
m_mapInfos[ m_numMapInfos ].spawnAngle[ i ] = 0;
}
if( --numBrace ) break;
m_numMapInfos++;
}
else
g_script.SkipLine();
}
if( !m_numMapInfos )
return false;
return true;
}
| C++ |
#if !defined(AFX_ATTACKPROC_H__6B6881F6_63C9_47BE_8986_1BD1EAB7A485__INCLUDED_)
#define AFX_ATTACKPROC_H__6B6881F6_63C9_47BE_8986_1BD1EAB7A485__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
SKILL_RESEND_INIT,
SKILL_RESEND_PREPARE,
SKILL_RESEND_COMPLETE
};
class CAttackProc
{
public:
int m_ntempAttackSuccessCount;
int m_ntempAttackMissCount;
public:
CAttackProc();
virtual ~CAttackProc();
int InTargetList( char* name );
int IsSaftTargeting();
void GTH_SendEventMessage_Attack();
int GTH_SendEventMessage_Skill();
int GTH_ProcessEventMessage_Attack();
int GTH_ProcessEventMessage_Damage();
bool GTH_EnableSkillExcuteDist(int SkillIndex,int TargetType,float fGap=2.0f, float fAddGap=0.0f);
};
extern CAttackProc g_AttackProc;
#endif
| C++ |
#include "Global.h"
#include "New.h"
#include <assert.h>
#include "GonryunPracticeBattle/CGonryunPractice_Ability.h"
#include "GonryunPracticeBattle/CGonryunPracticeBattle.h"
#include "GonryunPracticeBattle/CGonryunPractice_RewordCtrl.h"
#include "GonryunPracticeBattle/CGonryunPractice_Decoder.h"
#include "GonryunPracticeBattle/CGonryunPractice_RewordItem.h"
class CGonryunPractice_ProcessCtrl;
extern CGonryunPracticeBattle g_GonryunPracticeBattle;
#include "GolryunBattle\CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
#include "Terra\GiftCard\CGiftCard.h"
extern CGiftCard* gcpGiftCard;
#include "GM(Game Master)\CGMCtrl.h"
extern CGMCtrl* gcpGMCtrl;
#include "network/Gs_To_Gms.h"
extern CGs_To_Gms g_GsToGms;
#include "network/Gms_To_Gs.h"
extern CGms_To_Gs g_GmsToGs;
extern CItem_Scroll_Proc g_Item_Scroll_Proc;
#include "AHNLAB\AHNLAB.h"
extern CAhnLab* g_cpAhnLab;
int LoadGonryunBattlePracticeTableReword(char *filenameReword, CGonryunPractice_RewordCtrl* pPracticeRewordManager)
{
FILE *pfileReword=NULL;
int size;
byte *buffer;
char token[512];
if ( ( pfileReword = fopen( filenameReword, "rb" ) ) == NULL )
return 0;
fseek(pfileReword,0,SEEK_END);
size = ftell(pfileReword);
buffer = new byte[size+1];
fseek(pfileReword,0,SEEK_SET);
fread(buffer,size,1,pfileReword);
fclose(pfileReword);
curpos = (char *)buffer;
endpos = curpos + size;
int ret, idx = 0;
while (1)
{
ret = NextCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = NextCSVToken( token );
if ( ret == 1 )
{
if(buffer!=NULL)
{
delete [] buffer;
buffer=NULL;
}
return 1;
}
if ( ret == 2 ) break;
}
continue;
}
CGonryunPractice_Ability* pReword = new CGonryunPractice_Ability;
pReword->SetID(atoi( token ));
ret = NextCSVToken( token );
pReword->SetName(token);
ret = NextCSVToken( token );
pReword->SetType(atoi( token ));
ret = NextCSVToken( token );
pReword->SetExperience(atoi( token ));
ret = NextCSVToken( token );
pReword->SetExpRate(atoi( token ));
ret = NextCSVToken( token );
pReword->SetItemID(atoi( token ));
ret = NextCSVToken( token );
pReword->SetItemRate(atoi( token ));
ret = NextCSVToken( token );
if ( ret == 1 )
{
pPracticeRewordManager->GetRewordList().push_back(pReword);
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
if ( ret == 2 )
{
pPracticeRewordManager->GetRewordList().push_back(pReword);
continue;
}
}
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
int LoadGonryunBattlePracticeTableRewordItem(char *filenameRewordItem, CGonryunPractice_RewordCtrl* pPracticeRewordManager)
{
FILE *pfileRewordItem=NULL;
int size;
byte *buffer;
char token[512];
if ( ( pfileRewordItem = fopen( filenameRewordItem, "rb" ) ) == NULL )
return 0;
fseek(pfileRewordItem,0,SEEK_END);
size = ftell(pfileRewordItem);
buffer = new byte[size+1];
fseek(pfileRewordItem,0,SEEK_SET);
fread(buffer,size,1,pfileRewordItem);
fclose(pfileRewordItem);
curpos = (char *)buffer;
endpos = curpos + size;
int ret=0, idx = 0;
while (1) {
ret = NextCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = NextCSVToken( token );
if ( ret == 1 )
{
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
if ( ret == 2 ) break;
}
continue;
}
CGonryunPractice_RewordItem* pWrewordItem= new CGonryunPractice_RewordItem();
pWrewordItem->SetItemIndex(atoi( token ));
ret = NextCSVToken( token );
pWrewordItem->SetItemType(atoi( token ));
ret = NextCSVToken( token );
pWrewordItem->SetItemNumber(atoi( token ));
ret = NextCSVToken( token );
pWrewordItem->SetItemCount(atoi( token ));
ret = NextCSVToken( token );
pWrewordItem->SetItemRate(atoi( token ));
ret = NextCSVToken( token );
if ( ret == 1 )
{
pPracticeRewordManager->GetRewordItemList().push_back(pWrewordItem);
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
if ( ret == 2 )
{
pPracticeRewordManager->GetRewordItemList().push_back(pWrewordItem);
continue;
}
}
if(buffer!=NULL)
{
delete [] buffer;
}
return 1;
}
int GTH_ParseGameLogicConfig()
{
FILE *fp;
int size;
byte *buffer;
char *token;
int nextGrade;
itemUpgradeProbabilityTable_t * pUpgradeTable;
memset( &g_logic, 0, sizeof( gthGameLogicCofing_t ) );
g_logic.expRate = 1.0f;
g_logic.nseRate = 1.0f;
g_logic.cheatEnable = false;
g_logic.worldChattingPrice = 1000;
g_logic.m_SpawnPosOverRate = 1.0f;
fp = fopen( "logic.cfg" , "rb" );
if( !fp )
{
MessageBox(NULL, "does not exist 'logic.cfg' file", "Error", MB_ICONHAND|MB_OK);
return false;
}
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size+1];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
curpos = (char *)buffer;
endpos = curpos + size;
while ((token = NextToken()) != NULL)
{
if( !stricmp( token, "EXP_RATE" ) )
{
g_logic.expRate = atof( NextArg() );
}
else if( !stricmp( token, "NSE_RATE" ) )
{
g_logic.nseRate = atof( NextArg() );
}
else if( !stricmp( token, "ITEMDROP_RATE" ) )
{
g_logic.itemDropRate = atof( NextArg() );
}
else if( !stricmp( token, "GENCAPABILITY_RATE" ) )
{
g_logic.genCapabilityRate = atof( NextArg() );
}
else if( !stricmp( token, "CHEAT_ENABLE" ) )
{
token = NextToken();
if( !stricmp( token, "TRUE" ) ) g_logic.cheatEnable = true;
}
else if( !stricmp( token, "UPGRADE" ) )
{
token = NextToken();
if( !stricmp( token, "LEAFQUALITY" ) )
pUpgradeTable = &g_logic.leafStoneProTbl;
else if( !stricmp( token, "MADQUALITY" ) )
pUpgradeTable = &g_logic.madStoneProTbl;
else if( !stricmp( token, "WAVEQUALITY" ) )
pUpgradeTable = &g_logic.waveStoneProTbl;
else if( !stricmp( token, "FIREQUALITY" ) )
pUpgradeTable = &g_logic.fireStoneProTbl;
else if( !stricmp( token, "ARTQUALITY" ) )
pUpgradeTable = &g_logic.artStoneProTbl;
else
break;
token = NextToken();
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "GRADE" ) )
{
token = NextToken();
nextGrade = atoi( token );
token = NextToken();
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "SUCCESS_PRO" ) )
{
token = NextToken();
pUpgradeTable->successPro[nextGrade] = atof( token );
}
else if( !stricmp( token, "COST" ) )
{
token = NextToken();
pUpgradeTable->cost[nextGrade] = atoi( token );
}
else if( !stricmp( token, "VANISH_PRO" ) )
{
token = NextToken();
pUpgradeTable->vanishPro[nextGrade] = atof( token );
}
else if( !stricmp( token, "GRADEDOWN_PRO" ) )
{
token = NextToken();
pUpgradeTable->gradeDownPro[nextGrade] = atof( token );
}
else if( !stricmp( token, "GRADEDOWN_LEVEL" ) )
{
token = NextToken();
pUpgradeTable->gradeDownLevel[nextGrade] = atof( token );
}
}
}
}
}
}
}
else if( !stricmp( token, "GAMBLESTONE" ) )
{
int quality, grade;
token = NextToken();
g_logic.gambleTable[0].gradePro[4] = 0.0;
if( !stricmp( token, "LOWQUALITY" ) )
{
quality = 0;
}
else if( !stricmp( token, "HIGHQUALITY" ) )
{
quality = 1;
}
token = NextToken();
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "SUCCESS_PRO" ) )
{
token = NextToken();
g_logic.gambleTable[quality].successPro = atof( token ) / 100.0f;
}
else if( !stricmp( token, "COST" ) )
{
token = NextToken();
g_logic.gambleTable[quality].cost = atoi( token );
}
else if( !stricmp( token, "VANISH_PRO" ) )
{
token = NextToken();
g_logic.gambleTable[quality].vanishPro = atof( token ) / 100.0f;
}
else if( !stricmp( token, "GRADE" ) )
{
token = NextToken();
grade = atoi( token ) - 1 - quality*4;
token = NextToken();
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
if( !stricmp( token, "GRADE_PRO" ) )
{
token = NextToken();
g_logic.gambleTable[quality].gradePro[grade] = atof( token ) / 100.0f;
}
}
}
}
}
}
}
else if( !stricmp( token, "PENALTY" ) )
{
int chaosClass;
token = NextToken();
if( token[0] == '{' )
{
while( 1 )
{
token = NextToken();
if( token[0] == '}' ) break;
chaosClass = atoi( token );
token = NextToken();
g_logic.dieItemLossRate[chaosClass] = atof( token );
token = NextToken();
g_logic.dieExpLossRate[chaosClass] = atof( token );
}
}
}
else if( !stricmp( token, "WORLDCHATTING_PRICE" ) )
{
token = NextToken();
g_logic.worldChattingPrice = atoi( token );
}
else if ( !stricmp (token, "DAN_BATTLE_PRICE" ) )
{
token = NextToken();
g_logic.DanBattlePrice = atoi(token);
}
else if ( !stricmp (token, "GAMBLE_OPTION" ) )
{
token = NextToken();
int CurOpiontNumber = 0;
int GradeCount = 0;
if ( !stricmp (token, "{" ) )
{
while ( 1)
{
token = NextToken();
if ( !stricmp (token, "}" ) )
break;
if ( !stricmp (token, "GRADE_COUNT" ) )
{
token = NextToken();
GradeCount = atoi(token);
}
if ( !stricmp (token, "SELECT_RATE" ) )
{
token = NextToken();
g_logic.gambleSelectOptionTable[CurOpiontNumber].SelectOptionRate = atof(token);
g_logic.gambleSelectOptionTable[CurOpiontNumber].SelectOptionCount = CurOpiontNumber;
}
if ( !stricmp (token, "GAMBLE_PRICE_RATE" ) )
{
token = NextToken();
g_logic.GamblePriceRate = atof(token);
}
if ( !stricmp (token, "SELECT_GRADE" ) )
{
for (int i = 0; i < GradeCount; i ++)
{
token = NextToken();
g_logic.gambleSelectOptionTable[CurOpiontNumber].SelectOptionGraderate[i] = atof(token);
}
CurOpiontNumber++;
}
if ( !stricmp (token, "ESSENCE_RATE" ) )
{
token = NextToken();
g_logic.gambleitemSelectRate[0] = atof(token);
}
if ( !stricmp (token, "ADVANCED_RATE" ) )
{
token = NextToken();
g_logic.gambleitemSelectRate[1] = atof(token);
}
if ( !stricmp (token, "MYSTIC_RATE" ) )
{
token = NextToken();
g_logic.gambleitemSelectRate[2] = atof(token);
}
if ( !stricmp (token, "CLASSIC_RATE" ) )
{
token = NextToken();
g_logic.gambleitemSelectRate[3] = atof(token);
}
if ( !stricmp (token, "UNIQUE_RATE" ) )
{
token = NextToken();
g_logic.gambleitemSelectRate[4] = atof(token);
}
}
}
}
else if( !stricmp( token, "DS_TIME_STARTUP" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_STARTUP] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_READY" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_READY] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_MOVE" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_START" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_START] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_END" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_END] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_LOOSE_MOVE" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_LOOSE_MOVE] = atoi( token );
}
else if( !stricmp( token, "DS_TIME_CLEAR" ) )
{
token = NextToken();
g_logic.danBattleStatusTime[DBTL_STATUS_CLEAR] = atoi( token );
}
else if( !stricmp( token, "DAN_BATTLE_PORTAL_START_POS" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartworldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_PORTAL_TARGET_POS" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_PORTAL_TARGET_POS2" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx2 = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos2[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_ATEAM_START_PORTAL_POS" ))
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartworldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_ATEAM_TARGET_PORTAL_POS" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetWorldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_BTEAM_START_PORTAL_POS" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartworldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_BTEAM_TARGET_PORTAL_POS" ) )
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetWorldIdx = atoi( token );
for (int i = 0; i < 3; i ++)
{
token = NextToken();
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetPos[i] = atof( token );
}
}
else if( !stricmp( token, "DAN_BATTLE_WIN_REWARD_FOR_DAN" ) )
{
token = NextToken();
g_logic.danBattleReward[DANB_WIN_DAN] = atoi( token );
}
else if( !stricmp( token, "DAN_BATTLE_WIN_REWARD_FOR_USER" ) )
{
token = NextToken();
g_logic.danBattleReward[DANB_WIN_USER] = atoi( token );
}
else if( !stricmp( token, "DAN_BATTLE_LOOSE_REWARD_FOR_DAN" ) )
{
token = NextToken();
g_logic.danBattleReward[DANB_LOOSE_DAN] = atoi( token );
}
else if( !stricmp( token, "DAN_BATTLE_LOOSE_REWARD_FOR_USER" ) )
{
token = NextToken();
g_logic.danBattleReward[DANB_LOOSE_USER] = atoi( token );
}
else if( !stricmp(token,"DAN_MARK_CHANGE_DELAY_HOUR"))
{
token = NextToken();
g_logic.danMarkChangeDelayHour = atoi(token);
assert(g_logic.danMarkChangeDelayHour >= 0);
assert(g_logic.danMarkChangeDelayHour <= 24 * 30);
if(g_logic.danMarkChangeDelayHour < 0) g_logic.danMarkChangeDelayHour=1;
if(g_logic.danMarkChangeDelayHour > 24 * 30) g_logic.danMarkChangeDelayHour=24 * 30;
}
else if( !stricmp( token, "PCB_NONE" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_NONE] = atoi( token );
}
else if( !stricmp( token, "PCB_SUGGUEST" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_SUGGUEST] = atoi( token );
}
else if( !stricmp( token, "PCB_BATTING" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_BATTING] = atoi( token );
}
else if( !stricmp( token, "PCB_READY" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_BATTLE_READY] = atoi( token );
}
else if( !stricmp( token, "PCB_START" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_FIGHTING] = atoi( token );
}
else if( !stricmp( token, "PCB_END" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.PCBStatusTime[CGonryunPractice_ProcessCtrl::Step::STEP_BATTLE_END] = atoi( token );
}
else if( !stricmp( token, "PCB_WAIT" ) )
{
token = NextToken();
}
else if( !stricmp( token, "PCB_MINILEVEL" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_iminiLevel = atoi( token );
}
else if( !stricmp( token, "PCB_MAXLEVEL" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_imaxLevel = atoi( token );
}
else if( !stricmp( token, "PCB_DIFFERLEVEL" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_idifferLevel = atoi( token );
}
else if( !stricmp( token, "PCB_ROYALTY" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_iroyalty= atoi( token );
}
else if( !stricmp( token, "PCB_BATTINGROYALTY" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_ibattingRoyalty = atoi( token );
}
else if( !stricmp( token, "PCB_USECOUNT" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_iuseCount = atoi( token );
}
else if( !stricmp( token, "PCB_ACTIVE" ) )
{
token = NextToken();
g_GonryunPracticeBattle.GetProcessCtrl()->SetActive(atoi( token ));
}
else if( !stricmp( token, "PCB_SYEN_LEVEL" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_isyenminilevel = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_isyenmaxlevel = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_ALAYAN_READER_IN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanReaderPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanReaderPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanReaderPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanReaderPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_ALAYAN_OPENENT_IN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanOpenentPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanOpenentPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanOpenentPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanOpenentPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_ALAYAN_WINNER_OUT" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_ALAYAN_DEFEATOR_OUT" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayandefeatorOutPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayandefeatorOutPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayandefeatorOutPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tarayandefeatorOutPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_SYEN_READER_IN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenReaderPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenReaderPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenReaderPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenReaderPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_SYEN_OPENENT_IN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenOpenentPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenOpenentPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenOpenentPos.m_fbattlein_z = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tasyenOpenentPos.m_fbattlein_yaw = atoi( token );
}
else if( !stricmp( token, "PCB_POTALPOSITION_SYEN_OUT" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_x = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_y = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_z = atoi( token );
}
else if( !stricmp( token, "PCB_ORIGINPOSITION_ALAYAN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.origin_ArayanOutPos[0] = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.origin_ArayanOutPos[1] = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.origin_ArayanOutPos[2] = atoi( token );
}
else if( !stricmp( token, "PCB_ORIGINPOSITION_SYEN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.origin_syenOutPos[0] = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.origin_syenOutPos[1] = atoi( token );
token = NextToken();
g_logic.PCBGonryunCondition.origin_syenOutPos[2] = atoi( token );
}
else if( !stricmp( token, "PCB_BATTLE_IN" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.pcpBattleIn = atoi( token );
}
else if( !stricmp( token, "PCB_PAY_EXPRATE" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.fExpRate = atoi( token );
}
else if( !stricmp( token, "PCB_PAY_ITEMRATE" ) )
{
token = NextToken();
g_logic.PCBGonryunCondition.fItemRate = atoi( token );
}
else if(!stricmp( token, "HELPER_LEVEL_POINT" ))
{
token = NextToken();
g_logic.HelperLevelPoint.iLevel1 = atoi( token );
token = NextToken();
g_logic.HelperLevelPoint.iLevel4 = atoi( token );
token = NextToken();
g_logic.HelperLevelPoint.iLevel10 = atoi( token );
token = NextToken();
g_logic.HelperLevelPoint.iLevel20 = atoi( token );
token = NextToken();
g_logic.HelperLevelPoint.iLevel30 = atoi( token );
}
else if ( !stricmp (token, "CASHAMLL_ITEM" ) )
{
token = NextToken();
int GradeCount = 0;
CashMallItem_OptionStone::enumUseItemMode mode;
mode = CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE;
if ( !stricmp (token, "{" ) )
{
while ( 1)
{
token = NextToken();
if ( !stricmp (token, "}" ) )
break;
if ( !stricmp (token, "}" ) )
break;
if ( !stricmp (token, "STONE_TYPE" ) )
{
token = NextToken();
if ( !stricmp(token, "STONE_OF_SAGE") )
mode = CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE;
if ( !stricmp(token, "STONE_OF_UNKNOWN") )
mode = CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY;
if ( !stricmp(token, "STONE_OF_EACH_NAME") )
mode = CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME;
}
if ( !stricmp (token, "DESTROY_RATE" ) )
{
token = NextToken();
g_logic.OptionStoneItemLogic[mode].DestroyRate = atof(token);
}
if ( !stricmp (token, "SUCCECS_RATE" ) )
{
token = NextToken();
g_logic.OptionStoneItemLogic[mode].SuccecsRate = atof(token);
}
if ( !stricmp (token, "SELECT_GRADE" ) )
{
for (int iGradeIdx = 0; iGradeIdx < MAX_NUMBER_OF_OPTION_VALUE_GRADE; iGradeIdx ++)
{
token = NextToken();
g_logic.OptionStoneItemLogic[mode].OptionGrade[iGradeIdx] = atof(token);
}
}
}
}
}
else if (!stricmp(token, "NEW_DBATTLE_PC_COUNT"))
{
token = NextToken();
g_NewDanBattleSystem.m_nMinPcCount = atoi(token);
}
else if (!stricmp(token, "NEW_DBATTLE_TIME1"))
{
token = NextToken();
g_NewDanBattleSystem.m_nBattleTimeForMin1 = atoi(token);
}
else if (!stricmp(token, "NEW_DBATTLE_TIME2"))
{
token = NextToken();
g_NewDanBattleSystem.m_nBattleTimeForMin2 = atoi(token);
}
else if (!stricmp(token, "NEW_DBATTLE_ITEM_DROPRATE"))
{
token = NextToken();
g_NewDanBattleSystem.m_fItemDropRate = atof(token);
}
else if (!stricmp(token, "NEW_DBATTLE_WAIT_TIME_READY"))
{
token = NextToken();
g_NewDanBattleSystem.m_WaitTimeforReady = atof(token);
}
else if (!stricmp(token, "NEW_DBATTLE_WAIT_TIME_END"))
{
token = NextToken();
g_NewDanBattleSystem.m_WaitTimeforEnd = atof(token);
}
}
fclose(fp);
if(buffer!=NULL)
{
delete [] buffer;
}
return true;
}
extern char *g_lTableToken[];
#include "CPremiumPlayerCtrl.h"
extern CPremiumPlayerCtrl* gcpPremiumPlayerCtrl;
void GTH_ProcessMessage_LogicReload()
{
DWORD StartTime=timeGetTime();
DWORD Endtime;
GTH_ParseGameLogicConfig();
char filename[MAX_PATH];
sprintf( filename, "l_tables/GonryunBattleRewardField%s.csv", g_lTableToken[g_config.languageType] );
if( !LoadGonryunBattlePracticeTableReword(filename, g_GonryunPracticeBattle.GetRewordCtrl() ))
{
g_logSystem->Write("LoadGonryunBattlePracticeTableReword!");
}
sprintf( filename, "l_tables/GonryunBattleRewardItem%s.csv", g_lTableToken[g_config.languageType] );
if( !LoadGonryunBattlePracticeTableRewordItem(filename, g_GonryunPracticeBattle.GetRewordCtrl()))
{
g_logSystem->Write("LoadGonryunBattlePracticeTableRewordItem!");
}
Endtime=timeGetTime();
ShowLogInfo("Logic ReloadTime : %d",Endtime-StartTime);
gcpPremiumPlayerCtrl->LoadIniFile();
gGameConfigFlag.LoadFlagFile();
}
void GTH_ProcessMessage_Client_Extend()
{
byte command = MSG_ReadByte();
switch(command)
{
case CC_SUB_EVENT_SOCIAL_SHOUT:
GTH_PC_Shout(g_curPC);
break;
case CC_SUB_EVENT_SOCIAL_BOW:
GTH_PC_BOW(g_curPC);
break;
case CC_MAILSYSTEM :
GTH_ProcessMessage_MailSystem();
break;
case CC_WORLDCHATTING :
GTH_ProcessMessage_WorldChatting();
break;
case CC_SAVE_SKIN_PART :
GTH_ProcessMessage_SkinPart();
break;
case CC_DAN_BATTLE :
g_DanBattleFunc.RecvCC_DanBattleMessage();
break;
case GSM_DAN_BATTLE :
g_DanBattleFunc.RecvGSM_DanBattleMessage();
break;
case CC_REQUEST_GONRYUNBATTLEPRACTICE:
g_GonryunPracticeBattle.GetDecoder()->recvPacket();
break;
case CC_GB_BATTLE:
(gcpGolryunBattle->GetDecoderClassPointer())->Decoder();
break;
case CC_RELOAD_LOGIC :
GTH_ProcessMessage_LogicReload();
break;
case CC_REQUEST_CHRISTMAS_EVENT:
g_ChristMasEvent.GTH_Process_ChristMas_Event();
break;
case CC_POSTSYSTEM:
g_PostFunc.GTH_ProcessMessage_PostSystem();
break;
case CC_MAILBOX:
g_PostFunc.GTH_ProcessMessage_MailBox();
break;
case CC_REQUEST_USE_EPACK_CHARG_SOUL:
GTH_ProcessMessage_Request_Epack_ChargSoul();
break;
case CC_EXTEND_WORLDCHATTING_COUNT :
GTH_ProcessMessage_WorldChattingCount();
break;
case CC_WORLD_CHANGE:
GTH_WorldChangeSystem_Process();
break;
}
}
void GTH_ProcessMessage_Client_Extend_Second()
{
enum enumExtendSecondPacket SecoundPacket;
SecoundPacket = static_cast <enum enumExtendSecondPacket>(MSG_ReadShort());
switch(SecoundPacket)
{
case HELPER_SYSTEM:
g_HelperManager.ProcessMessage_Helper();
return;
case EXP_EVENT:
g_ExpEventMng.ProcessExpEvent();
return;
case GMsystem:
gcpGMCtrl->Decoder(g_curPC);
return;
}
if(NULL == g_curPC) return;
if( !g_curPC->ready ) return;
switch(SecoundPacket)
{
case GIFTCARD:
gcpGiftCard->Decoder(g_curPC);
return;
case WEATHER_SYSTEM:
g_WeatherSystem.GTH_Process_Weather_System();
break;
case ITEM_REPAIR:
GTH_ProcessMessage_RepairItemConfirm();
break;
case CASH_MALL_ITEM:
GTH_DecodeCashMallItem();
break;
case GAMBLE_SYSTEM:
GambleSystemDecode();
break;
case ITEM_EXTEND_SYSTEM:
GTH_ItemExtendSystemDecode();
break;
case AHNLAB:
{
if ( NULL != g_cpAhnLab )
g_cpAhnLab->GTH_ProcessMessageAhnLabMessage(g_curPC);
}
break;
case NEW_DANBATTLE:
GTH_DecodeDanBattleSystem();
break;
default:
return;
}
}
| C++ |
#include "Attack.h"
CAttack::CAttack()
{
}
CAttack::~CAttack()
{
}
| C++ |
#if !defined(AFX_CTOOLS_H__27E5ED11_4334_47F6_80B0_D401A9E1F9D4__INCLUDED_)
#define AFX_CTOOLS_H__27E5ED11_4334_47F6_80B0_D401A9E1F9D4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTools
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
skill_t* GetMySkillTpointer(playerCharacter_t* pPlayer,const int Idx);
playerCharacter_t* GetPlayerRecordPointer(const int Idx);
playerCharacter_t* GetPlayerRecordPointer(const querySet_t& querySet);
playerCharacter_t* GetPlayerRecordPointer(const char* pName);
void IncDecChaosPoint(playerCharacter_t* pPlayer,const int changePoint);
BOOL DeleteItemFromMyInventory(playerCharacter_t* pPlayer,const int iInventoryIdx,const int ItemTableIdx, int DeleteNum = 1);
public:
monsterCharacter_t* GetNPCRecordPointer(const int Idx);
public:
monsterCharacter_t* GetMonsterRecordPointer(const int Idx);
private:
inline BOOL AddItem_Inventory(playerCharacter_t* pPlayer,const int ItemArrayIdx);
inline BOOL AddItem_DropMap(playerCharacter_t* pPlayer,const int ItemArrayIdx);
public:
BOOL IsStackItem(const item_t* in_pItem);
itemTable_t* GetItemTablePointer(const int in_nItemTableIdx);
item_t* GetMyItem(playerCharacter_t* in_pPlayer,const int in_nMyItemArrayIdx);
int AddItem(playerCharacter_t* pPlayer,item_t& item, BOOL bDropItem = TRUE);
int GetMatchMyInventoryIdx_fromItemTable(playerCharacter_t* pPlayer,const int paramItemTableIdx);
BOOL AddItemBatting(playerCharacter_t* pPlayer,item_t& item);
int GetMatchMyItemIdx_fromINVENTORY(playerCharacter_t* pPlayer,const int paramItemTableIdx);
public:
int GetEpkChargeCount(item_t *pItem);
void SetEpkChargeCount(item_t *pItem,int count);
BOOL isSummonAllow(playerCharacter_t* pPlayer);
bool IsTransformEntity( void *ent, int entType );
item_t* GetMyInventoryItem(playerCharacter_t* pPlayer,const int InventoryPos);
BOOL DeleteItemFromMyInventory(playerCharacter_t* pPlayer,const int iInventoryIdx);
BOOL isReady(const playerCharacter_t* in_pPlayer);
public:
CTools();
virtual ~CTools();
};
#endif
| C++ |
#if !defined(AFX_CTEMPPLAYERINVENTORYX_H__D5B5B114_473F_4E3F_A4D0_B88814CB1771__INCLUDED_)
#define AFX_CTEMPPLAYERINVENTORYX_H__D5B5B114_473F_4E3F_A4D0_B88814CB1771__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTempPlayerInventoryX
{
public:
enum ErrorCode{
ErrorCode_Success=0,
ErrorCode_unknown,
ErrorCode_Over_Weight,
ErrorCode_NotEnough_Inventory,
ErrorCode_stacknum_overflow,
};
private:
struct tagTempInventory{
int TableIdx;
int numberIdx;
};
struct tagTempInventory m_TempInventory[MAX_INVENTORY_SIZE];
BOOL m_bOK;
int m_curWeight;
int m_maxWeight;
private:
BOOL Init(const playerCharacter_t* pPlayer);
public:
BOOL isOK(void) const;
const ErrorCode Insert(const item_t* pItem);
public:
CTempPlayerInventoryX(const playerCharacter_t* pPlayer);
virtual ~CTempPlayerInventoryX();
};
#endif
| C++ |
#include "../Global.h"
#include "CTempPlayerInventoryX.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
CTempPlayerInventoryX::CTempPlayerInventoryX(const playerCharacter_t* pPlayer)
{
m_bOK=FALSE;
m_curWeight=0;
m_maxWeight=pPlayer->calItemWeight;
if(FALSE == Init(pPlayer)) return;
m_bOK=FALSE;
}
CTempPlayerInventoryX::~CTempPlayerInventoryX()
{
}
BOOL CTempPlayerInventoryX::isOK(void) const
{
return m_bOK;
}
BOOL CTempPlayerInventoryX::Init(const playerCharacter_t* pPlayer)
{
int ItemArrayidx=-1;
int InventoryIdx=-1;
item_t* pItem=NULL;
itemTable_t* pItemTable=NULL;
m_curWeight=0;
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
m_TempInventory[InventoryIdx].TableIdx=-1;
m_TempInventory[InventoryIdx].numberIdx=-1;
pItem = gcpTools->GetMyItem((playerCharacter_t*)pPlayer,pPlayer->inventory[InventoryIdx]);
if(NULL == pItem) continue;
pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable) continue;
m_curWeight = m_curWeight + pItemTable->weight;
m_TempInventory[InventoryIdx].TableIdx = pItem->itemTableIdx;
if(pItemTable->stackFlag) m_TempInventory[InventoryIdx].numberIdx= pItem->durability;
else m_TempInventory[InventoryIdx].numberIdx=-1;
}
return TRUE;
}
const CTempPlayerInventoryX::ErrorCode CTempPlayerInventoryX::Insert(const item_t* pItem)
{
itemTable_t* pItemTable=NULL;
pItemTable = gcpTools->GetItemTablePointer(pItem->itemTableIdx);
if(NULL == pItemTable){
return ErrorCode_unknown;
}
int weight = m_curWeight + pItemTable->weight;
if(weight > m_maxWeight) return ErrorCode_Over_Weight;
int InventoryIdx=-1;
if(pItemTable->stackFlag){
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if(m_TempInventory[InventoryIdx].TableIdx != pItem->itemTableIdx) continue;
int numberIdx = m_TempInventory[InventoryIdx].numberIdx + (pItem->durability + 1);
if(numberIdx >= MAX_COUNT_STACK_ITEM) return ErrorCode_stacknum_overflow;
m_TempInventory[InventoryIdx].numberIdx = numberIdx;
return ErrorCode_Success;
}
}
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if(m_TempInventory[InventoryIdx].TableIdx >= 0) continue;
m_TempInventory[InventoryIdx].TableIdx = pItem->itemTableIdx;
m_TempInventory[InventoryIdx].numberIdx = pItem->durability;
return ErrorCode_Success;
}
return ErrorCode_NotEnough_Inventory;
}
| C++ |
#if !defined(AFX_CGIFTCARD_H__ED7B3319_E69E_4406_9AF7_13EE4CBBE340__INCLUDED_)
#define AFX_CGIFTCARD_H__ED7B3319_E69E_4406_9AF7_13EE4CBBE340__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGiftCard
{
public:
enum enumCode{
success=0,
can_not_find,
password_not_match,
pre_use,
unknown,
};
private:
BOOL m_bOK;
public:
void Decoder(playerCharacter_t* pPlayer) const;
inline void Decoder_CS_Request(playerCharacter_t* pPlayer) const;
inline void Decoder_CS_CloseWindow(playerCharacter_t* pPlayer) const;
public:
BOOL isOK(void) const;
void TransmitePacket_SC_Notify(playerCharacter_t* pPlayer,enum enumCode code) const;
void TransmitePacket_SC_AddItem(playerCharacter_t* pPlayer,item_t& Item) const;
void TransmitePacket_SC_Close(playerCharacter_t* pPlayer) const;
void TransmitePacket_SC_Open(playerCharacter_t* pPlayer) const;
public:
CGiftCard();
virtual ~CGiftCard();
};
#endif
| C++ |
#include "../../global.h"
#include "CGiftCard.h"
#include "../../Tools/CTools.h"
extern CTools* gcpTools;
#include "tagGiftCardPacket.h"
CGiftCard::CGiftCard()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CGiftCard::~CGiftCard()
{
}
BOOL CGiftCard::isOK(void) const
{
return m_bOK;
}
void CGiftCard::TransmitePacket_SC_Notify(playerCharacter_t* pPlayer,enum enumCode code) const
{
enum tagGiftCardPacket_Notify::enumCode tr_code=
tagGiftCardPacket_Notify::enumCode::unknown;
switch(code){
case success:
tr_code=tagGiftCardPacket_Notify::enumCode::success;
break;
case can_not_find:
tr_code=tagGiftCardPacket_Notify::enumCode::can_not_find;
break;
case password_not_match:
tr_code=tagGiftCardPacket_Notify::enumCode::password_not_match;
break;
case pre_use:
tr_code=tagGiftCardPacket_Notify::enumCode::pre_use;
break;
case unknown:
tr_code=tagGiftCardPacket_Notify::enumCode::unknown;
break;
};
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GIFTCARD);
MSG_WriteShort(&netMessage, tagGiftCardPacket::enumPacketID::SC_Notify);
MSG_WriteByte(&netMessage, tr_code);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGiftCard::TransmitePacket_SC_Close(playerCharacter_t* pPlayer) const
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GIFTCARD);
MSG_WriteShort(&netMessage, tagGiftCardPacket::enumPacketID::SC_Close);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGiftCard::TransmitePacket_SC_AddItem(playerCharacter_t* pPlayer,item_t& Item) const
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GIFTCARD);
MSG_WriteShort(&netMessage, tagGiftCardPacket::enumPacketID::SC_AddItem);
MSG_WriteItem(&netMessage,&Item);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGiftCard::TransmitePacket_SC_Open(playerCharacter_t* pPlayer) const
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GIFTCARD);
MSG_WriteShort(&netMessage, tagGiftCardPacket::enumPacketID::SC_Open);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGiftCard::Decoder_CS_Request(playerCharacter_t* pPlayer) const
{
if(pPlayer->GiftCard.step != playerCharacter_t::tagGiftCard::step_none){
TransmitePacket_SC_Notify(pPlayer,CGiftCard::enumCode::unknown);
return;
}
pPlayer->GiftCard.step = playerCharacter_t::tagGiftCard::step_request;
strncpy(pPlayer->GiftCard.serial,MSG_ReadString(),playerCharacter_t::tagGiftCard::maxbytes_serial_num);
pPlayer->GiftCard.serial[playerCharacter_t::tagGiftCard::maxbytes_serial_num]=NULL;
strncpy(pPlayer->GiftCard.password,MSG_ReadString(),
playerCharacter_t::tagGiftCard::maxbytes_password);
pPlayer->GiftCard.password[playerCharacter_t::tagGiftCard::maxbytes_password]=NULL;
g_DBGameServer->LoadGiftCard(pPlayer);
}
void CGiftCard::Decoder_CS_CloseWindow(playerCharacter_t* pPlayer) const
{
if(pPlayer->busyState == BUSY_STATE_NPC){
pPlayer->busyState = BUSY_STATE_NONE;
monsterCharacter_t* pNPC=gcpTools->GetNPCRecordPointer(pPlayer->npcIdx);
if(NULL != pNPC){
NPC_DeleteNoticePC(pNPC,pPlayer);
}
}
}
void CGiftCard::Decoder(playerCharacter_t* pPlayer) const
{
enum tagGiftCardPacket::enumPacketID PacketID=
(enum tagGiftCardPacket::enumPacketID)MSG_ReadShort();
switch(PacketID){
case tagGiftCardPacket::enumPacketID::CS_Request:
Decoder_CS_Request(pPlayer);
break;
case tagGiftCardPacket::enumPacketID::CS_Close:
Decoder_CS_CloseWindow(pPlayer);
break;
}
}
| C++ |
#include "../..\global.h"
#include "CTerraBillingCtrl_LogCtrl.h"
#include "tagTerraBilling.h"
extern struct tagTerraBilling gTerraBilling;
CTerraBillingCtrl_LogCtrl::CTerraBillingCtrl_LogCtrl()
{
m_bOK=FALSE;
m_generationHour=25;
m_fp=NULL;
m_NextUpdateTime=g_globalTime-100;
m_bOK=TRUE;
}
CTerraBillingCtrl_LogCtrl::~CTerraBillingCtrl_LogCtrl()
{
CloseFile();
}
BOOL CTerraBillingCtrl_LogCtrl::isOK(void) const
{
return m_bOK;
}
void CTerraBillingCtrl_LogCtrl::Update(void)
{
if(FALSE == gTerraBilling.Log.bOutput) return;
if(m_NextUpdateTime > g_globalTime) return;
m_NextUpdateTime=g_globalTime + gTerraBilling.Log.UpdateCycle;
CloseFile();
OpenFile();
}
inline void CTerraBillingCtrl_LogCtrl::CloseFile(void)
{
if(NULL != m_fp){ fclose(m_fp); m_fp=NULL; }
}
void CTerraBillingCtrl_LogCtrl::Write(const char* format, ... )
{
if(FALSE == gTerraBilling.Log.bOutput) return;
if(NULL == m_fp){
if(FALSE == OpenFile()) return;
}
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1];
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes, format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
const int bytes_strTime=24;
char strTime[bytes_strTime+1];
time_t Time;
time( &Time );
strncpy(strTime, ::ctime(&Time),bytes_strTime);
strTime[bytes_strTime] = NULL;
fprintf(m_fp,"[%s] %s\n",strTime,buffer);
}
char* CTerraBillingCtrl_LogCtrl::GetYESNOstring(BOOL bYESorNO)
{
static char* pYESstring = "yes";
static char* pNOstring = "no";
if(TRUE == bYESorNO) return pYESstring;
return pNOstring;
}
inline BOOL CTerraBillingCtrl_LogCtrl::OpenFile(void)
{
struct tm* date_tm;
long Time;
time(&Time);
date_tm = localtime(&Time);
if(m_generationHour != date_tm->tm_hour){
m_generationHour = date_tm->tm_hour;
date_tm->tm_year += 1900;
date_tm->tm_mon += 1;
#ifdef _GAME_SERVER
wsprintf(m_szFileName,"billinglogs/Terra%02d%02d_%04d%02d%02d_%02d.log",g_config.serverGroupNo,g_config.gameServerNo,date_tm->tm_year,date_tm->tm_mon,date_tm->tm_mday,date_tm->tm_hour);
#endif
#ifdef _MASTER_SERVER
wsprintf(m_szFileName,"billinglogs/Terra%02d_%04d%02d%02d_%02d.log",g_config.serverNo,date_tm->tm_year,date_tm->tm_mon,date_tm->tm_mday,date_tm->tm_hour);
#endif
}
m_fp = fopen(m_szFileName,"a+");
if(NULL == m_fp) return FALSE;
return TRUE;
} | C++ |
#include "..\..\global.h"
#include "CTerraBillingCtrl_CommunicationCtrl.h"
#include <process.h>
#include <assert.h>
#include "CTerraBillingCtrl_CircularQueueCtrl.h"
#include "CTerraBillingCtrl_ReceiveCircualrQueueCtrl.h"
extern CTerraBillingCtrl_CircularQueueCtrl* gcpTerraBillingCtrl_TransmiteCircularQueueCtrl;
extern CTerraBillingCtrl_ReceiveCircualrQueueCtrl* gcpTerraBillingCtrl_ReceiveCircularQueueCtrl;
#include "CTerraBillingCtrl_Encoder.h"
extern CTerraBillingCtrl_Encoder* gcpTerraBillingCtrl_Encder;
CTerraBillingCtrl_CommunicationCtrl::CTerraBillingCtrl_CommunicationCtrl()
{
m_bOK=FALSE;
m_sock =INVALID_SOCKET;
m_ThreadVar.bLive=FALSE;
m_ThreadVar.bReqExit=FALSE;
m_Step = step_disconnect;
{
unsigned int threadID = 0 ;
HANDLE hThread = INVALID_HANDLE_VALUE;
hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunction, (void*)this, 0, &threadID) ;
if(hThread == INVALID_HANDLE_VALUE) return;
::CloseHandle(hThread);
hThread = INVALID_HANDLE_VALUE;
}
m_bOK=TRUE;
}
CTerraBillingCtrl_CommunicationCtrl::~CTerraBillingCtrl_CommunicationCtrl()
{
SocketDestory();
m_ThreadVar.bReqExit=TRUE;
while(TRUE == m_ThreadVar.bLive){
Sleep(100);
}
Sleep(10);
}
BOOL CTerraBillingCtrl_CommunicationCtrl::isOK(void) const
{
return m_bOK;
}
enum CTerraBillingCtrl_CommunicationCtrl::enumStep
CTerraBillingCtrl_CommunicationCtrl::GetStep(void)
{
return m_Step;
}
inline void CTerraBillingCtrl_CommunicationCtrl::SocketDestory(void)
{
if(INVALID_SOCKET != m_sock){
closesocket(m_sock);
m_sock=INVALID_SOCKET;
}
}
inline BOOL CTerraBillingCtrl_CommunicationCtrl::SocketCreate(void)
{
m_sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP) ;
if ( INVALID_SOCKET == m_sock )
{
return FALSE;
}
return TRUE;
}
inline void CTerraBillingCtrl_CommunicationCtrl::Disconnect(void)
{
assert(INVALID_SOCKET != m_sock);
SocketDestory() ;
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Clear();
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Clear();
}
unsigned int __stdcall CTerraBillingCtrl_CommunicationCtrl::ThreadFunction(void* pV)
{
CTerraBillingCtrl_CommunicationCtrl* cpCommunicationCtrl = (CTerraBillingCtrl_CommunicationCtrl*)pV ;
assert(NULL != cpCommunicationCtrl);
cpCommunicationCtrl->RealThreadFunction();
return 1;
}
inline BOOL CTerraBillingCtrl_CommunicationCtrl::Connect(void)
{
SocketDestory();
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Clear();
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Clear();
if(FALSE == SocketCreate()) return FALSE;
CInternetAddress servAddr(m_addr,m_port) ;
if(SOCKET_ERROR == connect(m_sock,(sockaddr*)&servAddr,sizeof(servAddr))) return FALSE;
return TRUE;
}
int CTerraBillingCtrl_CommunicationCtrl::RealThreadFunction(void)
{
struct tagAddBillPacket Packet;
int ret ;
m_ThreadVar.bLive=TRUE;
while(FALSE == m_ThreadVar.bReqExit){
switch(m_Step){
case step_disconnect:
default:
Sleep(10);
break;
case step_connect:
ret = recv( m_sock, (char*)&Packet, sizeof(struct tagAddBillPacket), 0 ) ;
if((SOCKET_ERROR == ret) || (0 == ret)){
m_Step = step_disconnect;
break;
}
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Push((unsigned char*)&Packet, ret);
break;
case step_connect_try:
if(TRUE == Connect()) m_Step = step_connect;
Sleep(10);
break;
}
}
m_ThreadVar.bLive=FALSE;
return 0 ;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::TryDisconnect(void)
{
switch(m_Step){
case step_connect:
SocketDestory();
m_Step = step_disconnect_try;
return TRUE;
}
return FALSE;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::
TryConnect(const unsigned long addr,const unsigned short port)
{
switch(m_Step){
case step_disconnect:
m_addr = addr;
m_port = port;
m_Step = step_connect_try;
return TRUE;
}
return FALSE;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::
Send(const struct tagAddBillPacket& Packet)
{
if(INVALID_SOCKET == m_sock) return FALSE;
int ret = send(m_sock,(char*)&Packet, sizeof(struct tagAddBillPacket), 0 ) ;
if(SOCKET_ERROR == ret) return FALSE;
return TRUE;
}
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_DECODER_H__0C021EEE_EF4D_445A_89C9_EF91A9ABCB06__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_DECODER_H__0C021EEE_EF4D_445A_89C9_EF91A9ABCB06__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagTerraPacket.h"
class CTerraBillingCtrl_Decoder
{
private:
BOOL m_bOK;
private:
#ifdef _MASTER_SERVER
inline i3client_t* GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const;
inline void Decoder_billing_authorization(const struct tagAddBillPacket& Packet) const;
#endif
public:
#ifdef _GAME_SERVER
inline playerCharacter_t* GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const;
inline void Decoder_game_start(const struct tagAddBillPacket& Packet) const;
inline void Decoder_user_sync(const struct tagAddBillPacket& Packet) const;
inline void Decoder_user_alert(const struct tagAddBillPacket& Packet) const;
#endif
public:
inline void Decoder_server_alive(const struct tagAddBillPacket& Packet) const;
public:
BOOL isOK(void) const;
void Decoder(const struct tagAddBillPacket& Packet);
public:
#ifdef _GAME_SERVER
void Transmite_TerraGCPacket_OpenMessageBox(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_OpenMessageBox::enumLPACKType LPACKType,
const int LPACKIdx,
enum tagTerraGCPacket_OpenMessageBox::enumAfter after) const;
void Transmite_TerraGCPacket_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_NoticeMessage::enumLPACKType LPACKType,
const int LPACKIdx) const;
void Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
const int RemainMinute) const;
#endif
public:
CTerraBillingCtrl_Decoder();
virtual ~CTerraBillingCtrl_Decoder();
};
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_CIRCULARQUEUECTRL_H__784A5F0E_B881_4660_BAA6_CF1333DD1626__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_CIRCULARQUEUECTRL_H__784A5F0E_B881_4660_BAA6_CF1333DD1626__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagAddBill.h"
class CTerraBillingCtrl_CircularQueueCtrl
{
protected:
BOOL m_bOK;
struct tagAddBillPacket* m_pBuffer;
int m_Number;
int m_ReadIdx;
int m_WriteIdx;
CRITICAL_SECTION m_critcalsection;
private:
BOOL Init(const int Number);
protected:
inline BOOL isEmpty(void) const;
inline BOOL isFull(void) const;
public:
BOOL isOK(void) const;
BOOL Push(const struct tagAddBillPacket* pData);
BOOL Pop(struct tagAddBillPacket& Data);
void Clear(void);
public:
CTerraBillingCtrl_CircularQueueCtrl(const int Number);
virtual ~CTerraBillingCtrl_CircularQueueCtrl();
};
#endif
| C++ |
#include "..\..\Global.h"
#include "CTerraBillingCtrl_Decoder.h"
#include "tagAddBill.h"
#include "CTerraBillingCtrl_Encoder.h"
extern CTerraBillingCtrl_Encoder* gcpTerraBillingCtrl_Encder;
#include "CTerraBillingCtrl_LogCtrl.h"
extern CTerraBillingCtrl_LogCtrl* gcpTerraCtrl_LogCtrl;
#ifdef _MASTER_SERVER
#include "..\CTerraCtrl.h"
extern CTerraCtrl* gcpTerraCtrl;
#endif
CTerraBillingCtrl_Decoder::CTerraBillingCtrl_Decoder()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CTerraBillingCtrl_Decoder::~CTerraBillingCtrl_Decoder()
{
}
BOOL CTerraBillingCtrl_Decoder::isOK(void) const
{
return m_bOK;
}
#ifdef _GAME_SERVER
inline playerCharacter_t* CTerraBillingCtrl_Decoder::GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const
{
char strIdx[tagAddBillPacket::maxbytes_session+1];
char strPlayerID[IDSTRING+1];
strncpy(strIdx,Packet.Session,tagAddBillPacket::maxbytes_session);
strIdx[tagAddBillPacket::maxbytes_session]=NULL;
if(NULL != strchr(strIdx,'-')) *strchr(strIdx,'-')=NULL;
strncpy(strPlayerID,Packet.User_ID,IDSTRING);
strPlayerID[IDSTRING]=NULL;
int Idx=atoi(strIdx);
if(Idx < 0) return NULL;
if(Idx > MAX_PCS) return NULL;
playerCharacter_t* pPlayerRecord=&g_pc[Idx];
if(FALSE == pPlayerRecord->active) return NULL;
if(FALSE == pPlayerRecord->ready) return NULL;
if(0 != strcmp(strPlayerID,pPlayerRecord->userID)) return NULL;
return pPlayerRecord;
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
const int RemainMinute) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, TERRA);
MSG_WriteShort(&netMessage, tagTerraGCPacket::Remain_Minute_NoticeMessage);
MSG_WriteLong(&netMessage, RemainMinute);
NET_SendMessage(&pToPlayerRecord->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_NoticeMessage::enumLPACKType LPACKType,
const int LPACKIdx) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, TERRA);
MSG_WriteShort(&netMessage, tagTerraGCPacket::NoticeMessage);
MSG_WriteByte(&netMessage, LPACKType);
MSG_WriteByte(&netMessage, LPACKIdx);
NET_SendMessage(&pToPlayerRecord->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_OpenMessageBox(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_OpenMessageBox::enumLPACKType LPACKType,
const int LPACKIdx,
enum tagTerraGCPacket_OpenMessageBox::enumAfter after) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, TERRA);
MSG_WriteShort(&netMessage, tagTerraGCPacket::Open_MessageBox);
MSG_WriteByte(&netMessage, LPACKType);
MSG_WriteByte(&netMessage, LPACKIdx);
MSG_WriteByte(&netMessage, after);
NET_SendMessage(&pToPlayerRecord->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_game_start(const struct tagAddBillPacket& Packet) const
{
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
gcpTerraBillingCtrl_Encder->Transmite_Game_End(Packet);
return;
}
switch(ntohl(Packet.Packet_Result)){
case tagAddBillPacket_Game_Start::enumResult::success:
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_billing;
strncpy(pPlayerRecord->AddBill.User_Status,Packet.User_Status,tagAddBillPacket::maxbytes_user_status);
break;
case tagAddBillPacket_Game_Start::enumResult::already_connected:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
1,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
case tagAddBillPacket_Game_Start::enumResult::illegal_user:
case tagAddBillPacket_Game_Start::enumResult::shortage_point:
case tagAddBillPacket_Game_Start::enumResult::not_exist_authorization:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
2,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
case tagAddBillPacket_Game_Start::enumResult::access_deny_db:
case tagAddBillPacket_Game_Start::enumResult::network_error:
case tagAddBillPacket_Game_Start::enumResult::not_exist_session:
case tagAddBillPacket_Game_Start::enumResult::unknown_packet:
case tagAddBillPacket_Game_Start::enumResult::error_com:
case tagAddBillPacket_Game_Start::enumResult::error_timeout_response_billserver:
case tagAddBillPacket_Game_Start::enumResult::connect_fail_billingDB:
case tagAddBillPacket_Game_Start::enumResult::unknown_game_no:
case tagAddBillPacket_Game_Start::enumResult::error_billing_account_service_module:
case tagAddBillPacket_Game_Start::enumResult::not_exist_authorization_this_game:
case tagAddBillPacket_Game_Start::enumResult::error_busy:
case tagAddBillPacket_Game_Start::enumResult::unknown:
case tagAddBillPacket_Game_Start::enumResult::com_error_when_ip_check:
case tagAddBillPacket_Game_Start::enumResult::not_enougf_service_provider:
case tagAddBillPacket_Game_Start::enumResult::com_error_when_authorization_key_check:
case tagAddBillPacket_Game_Start::enumResult::not_found_authorization_key:
default:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
3,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
}
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_user_sync(const struct tagAddBillPacket& Packet) const
{
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
gcpTerraBillingCtrl_Encder->Transmite_User_Sync(Packet);
return;
}
gcpTerraBillingCtrl_Encder->Transmite_User_Sync(pPlayerRecord);
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_user_alert(const struct tagAddBillPacket& Packet) const
{
static char message[_MAX_PATH];
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord) return;
switch(ntohl(Packet.Packet_Result)){
case tagAddBillPacket_User_Alert::enumResult::remain_time:
Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
pPlayerRecord,
ntohl(Packet.Bill_Remain));
return;
case tagAddBillPacket_User_Alert::enumResult::start_reserved_bill:
Transmite_TerraGCPacket_NoticeMessage(
pPlayerRecord,
tagTerraGCPacket_NoticeMessage::enumLPACKType::Billing,
7);
return;
case tagAddBillPacket_User_Alert::enumResult::now_log_off:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
4,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_end;
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::refund:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
5,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_end;
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::double_login:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
1,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_end;
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::force_exit:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
6,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_end;
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
}
}
#endif
inline void CTerraBillingCtrl_Decoder::
Decoder_server_alive(const struct tagAddBillPacket& ) const
{
}
void CTerraBillingCtrl_Decoder::Decoder(const struct tagAddBillPacket& Packet)
{
switch(ntohl(Packet.Packet_Type)){
case tagAddBillPacket::packet_type_server_alive:
Decoder_server_alive(Packet);
break;
#ifdef _GAME_SERVER
case tagAddBillPacket::packet_type_user_alert:
Decoder_user_alert(Packet);
break;
case tagAddBillPacket::packet_type_user_sync:
Decoder_user_sync(Packet);
break;
case tagAddBillPacket::packet_type_game_start:
Decoder_game_start(Packet);
break;
#endif
#ifdef _MASTER_SERVER
case tagAddBillPacket::packet_type_billing_authorization:
Decoder_billing_authorization(Packet);
break;
#endif
}
}
#ifdef _MASTER_SERVER
inline i3client_t* CTerraBillingCtrl_Decoder::GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const
{
char strIdx[tagAddBillPacket::maxbytes_session+1];
char strPlayerID[IDSTRING+1];
strncpy(strIdx,Packet.Session,tagAddBillPacket::maxbytes_session);
strIdx[tagAddBillPacket::maxbytes_session]=NULL;
strncpy(strPlayerID,Packet.User_ID,IDSTRING);
strPlayerID[IDSTRING]=NULL;
int Idx=atoi(strIdx);
if(Idx < 0) return NULL;
if(Idx > MAX_CLIENTS) return NULL;
i3client_t* pPlayerRecord=&g_clients[Idx];
if(0 != strcmp(strPlayerID,pPlayerRecord->id)) return NULL;
return pPlayerRecord;
};
#endif
#ifdef _MASTER_SERVER
inline void CTerraBillingCtrl_Decoder::Decoder_billing_authorization(const struct tagAddBillPacket& Packet) const
{
i3client_t* pPlayerRecord = GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
return;
}
int result=ntohl(Packet.Packet_Result);
switch(result){
case tagAddBillPacket::enumResult_billing_authorization::success:
gcpTerraCtrl->GTH_ReplyLogin(pPlayerRecord,tagTerraGCPacket_MSC_REPLYLOGIN::enumCode::success);
pPlayerRecord->isSuccessLogin = TRUE;
return;
case tagAddBillPacket::enumResult_billing_authorization::already_connected:
gcpTerraCtrl->GTH_ReplyLogin(pPlayerRecord,tagTerraGCPacket_MSC_REPLYLOGIN::enumCode::pre_login_user);
return;
case tagAddBillPacket::enumResult_billing_authorization::illegal_user:
case tagAddBillPacket::enumResult_billing_authorization::shortage_point:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_authorization:
gcpTerraCtrl->GTH_ReplyLogin(pPlayerRecord,tagTerraGCPacket_MSC_REPLYLOGIN::enumCode::billing_point_not_enough);
return;
case tagAddBillPacket::enumResult_billing_authorization::access_deny_db:
case tagAddBillPacket::enumResult_billing_authorization::network_error:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_session:
case tagAddBillPacket::enumResult_billing_authorization::unknown_packet:
case tagAddBillPacket::enumResult_billing_authorization::error_com:
case tagAddBillPacket::enumResult_billing_authorization::error_timeout_response_billserver:
case tagAddBillPacket::enumResult_billing_authorization::connect_fail_billingDB:
case tagAddBillPacket::enumResult_billing_authorization::unknown_game_no:
case tagAddBillPacket::enumResult_billing_authorization::error_billing_account_service_module:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_authorization_this_game:
case tagAddBillPacket::enumResult_billing_authorization::error_busy:
case tagAddBillPacket::enumResult_billing_authorization::unknown:
case tagAddBillPacket::enumResult_billing_authorization::com_error_when_ip_check:
case tagAddBillPacket::enumResult_billing_authorization::not_enougf_service_provider:
case tagAddBillPacket::enumResult_billing_authorization::com_error_when_authorization_key_check:
case tagAddBillPacket::enumResult_billing_authorization::not_found_authorization_key:
break;
}
gcpTerraCtrl->GTH_ReplyLogin(pPlayerRecord,tagTerraGCPacket_MSC_REPLYLOGIN::enumCode::unknown);
return;
}
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_LOGCTRL_H__1DC2AC1C_FE9B_490E_A4F0_2AF95AA14FDB__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_LOGCTRL_H__1DC2AC1C_FE9B_490E_A4F0_2AF95AA14FDB__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTerraBillingCtrl_LogCtrl
{
private:
BOOL m_bOK;
char m_szFileName[_MAX_PATH];
FILE* m_fp;
int m_NextUpdateTime;
int m_generationHour;
private:
inline BOOL OpenFile(void);
inline void CloseFile(void);
public:
BOOL isOK(void) const;
void Update(void);
void Write(const char* format, ... );
static char* GetYESNOstring(BOOL bYESorNO);
public:
CTerraBillingCtrl_LogCtrl();
virtual ~CTerraBillingCtrl_LogCtrl();
};
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_COMMUNICATIONCTRL_H__62234542_B22F_4A33_A2EF_4D23000EC4FB__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_COMMUNICATIONCTRL_H__62234542_B22F_4A33_A2EF_4D23000EC4FB__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTerraBillingCtrl_CommunicationCtrl
{
private:
BOOL m_bOK;
SOCKET m_sock;
unsigned long m_addr;
unsigned short m_port;
struct tagThreadVar{
BOOL bLive;
BOOL bReqExit;
};
struct tagThreadVar m_ThreadVar;
public:
enum enumStep{
step_disconnect_try=0,
step_disconnect,
step_connect_try,
step_connect,
};
private:
enum enumStep m_Step;
private:
inline BOOL SocketCreate(void);
inline void SocketDestory(void);
inline BOOL Connect(void);
inline void Disconnect(void);
private:
static unsigned int __stdcall ThreadFunction(void* pV);
int RealThreadFunction(void);
public:
BOOL isOK(void) const;
BOOL Start(void);
BOOL Send(const struct tagAddBillPacket& pPacket);
BOOL TryConnect(const unsigned long addr,const unsigned short port);
BOOL TryDisconnect(void);
enum enumStep GetStep(void);
public:
CTerraBillingCtrl_CommunicationCtrl();
virtual ~CTerraBillingCtrl_CommunicationCtrl();
};
#endif
| C++ |
#include "../../Global.h"
#include "CTerraBillingCtrl_Encoder.h"
#include "CTerraBillingCtrl_CircularQueueCtrl.h"
extern CTerraBillingCtrl_CircularQueueCtrl* gcpTerraBillingCtrl_TransmiteCircularQueueCtrl;
#include "tagTerraBilling.h"
extern struct tagTerraBilling gTerraBilling;
CTerraBillingCtrl_Encoder::CTerraBillingCtrl_Encoder()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CTerraBillingCtrl_Encoder::~CTerraBillingCtrl_Encoder()
{
}
BOOL CTerraBillingCtrl_Encoder::isOK(void) const
{
return m_bOK;
}
inline void CTerraBillingCtrl_Encoder::
SetSessionStr(struct tagAddBillPacket& Packet,const playerCharacter_t* pPlayer) const
{
char szPlayerIdx[20+1]="";
char szPlayerID[IDSTRING+1]="";
_snprintf(szPlayerIdx,20,"%d",pPlayer->idx);
szPlayerIdx[20]=NULL;
_snprintf(szPlayerID,IDSTRING,"%s",pPlayer->userID);
szPlayerID[IDSTRING]=NULL;
SetSessionStr(Packet,szPlayerIdx,szPlayerID);
}
inline void CTerraBillingCtrl_Encoder::
SetSessionStr(struct tagAddBillPacket& Packet,const char* pszPlayerIdx,const char* pszPlayerID) const
{
char temp[_MAX_PATH];
wsprintf(temp,"%s-%s-01234567890123456789012345678901",pszPlayerIdx,pszPlayerID);
strncpy(Packet.Session,temp,tagAddBillPacket::maxbytes_session);
}
void CTerraBillingCtrl_Encoder::Transmite_Server_Reset(void)
{
struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_server_reset);
memcpy(Packet.Game_Server,gTerraBilling.serverGUIDstring,tagAddBillPacket::maxbytes_serverGUIDstring);
Packet.Game_No = htonl(gTerraBilling.Game_No);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
void CTerraBillingCtrl_Encoder::Transmite_Server_Conn(void)
{
struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_server_conn);
memcpy(Packet.Game_Server,gTerraBilling.serverGUIDstring,tagAddBillPacket::maxbytes_serverGUIDstring);
Packet.Game_No = htonl(gTerraBilling.Game_No);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
#ifdef _MASTER_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_Billing_Authorization(const i3client_t* pPlayer)
{
struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_billing_authorization);
SetSessionStr(Packet,pPlayer);
wsprintf(Packet.User_CC,"TICT");
strncpy(Packet.User_ID,pPlayer->id,tagAddBillPacket::maxbytes_user_id);
wsprintf(Packet.User_IP,"%d:%d:%d:%d",
pPlayer->sock.addr.sin_addr.S_un.S_un_b.s_b1,
pPlayer->sock.addr.sin_addr.S_un.S_un_b.s_b2,
pPlayer->sock.addr.sin_addr.S_un.S_un_b.s_b3,
pPlayer->sock.addr.sin_addr.S_un.S_un_b.s_b4);
Packet.Game_No = htonl(gTerraBilling.Game_No);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_Game_Start(const playerCharacter_t* pPlayerRecord) const
{
static struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_game_start);
memcpy(Packet.Game_Server,gTerraBilling.serverGUIDstring,tagAddBillPacket::maxbytes_serverGUIDstring);
SetSessionStr(Packet,pPlayerRecord);
wsprintf(Packet.User_CC,"TICT");
strncpy(Packet.User_ID,pPlayerRecord->userID,tagAddBillPacket::maxbytes_user_id);
wsprintf(Packet.User_IP,"%d.%d.%d.%d",
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b1,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b2,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b3,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b4);
Packet.Game_No = htonl(gTerraBilling.Game_No);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_Game_End(const char* pszPlayerIdx,const char* pPlayerID,const char* pIPaddress,const char* pUser_Status) const
{
static struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_game_end);
SetSessionStr(Packet,pszPlayerIdx,pPlayerID);
wsprintf(Packet.User_CC,"TICT");
strncpy(Packet.User_ID,pPlayerID,tagAddBillPacket::maxbytes_user_id);
strncpy(Packet.User_IP,pIPaddress,tagAddBillPacket::maxbytes_user_ip);
strncpy(Packet.User_Status,pUser_Status,tagAddBillPacket::maxbytes_user_status);
Packet.Game_No = htonl(gTerraBilling.Game_No);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_Game_End(const struct tagAddBillPacket& Packet) const
{
Transmite_Game_End(Packet.Session,Packet.User_ID,Packet.User_IP,Packet.User_Status);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_Game_End(const playerCharacter_t* pPlayerRecord) const
{
static char strPlayerIdx[_MAX_PATH];
wsprintf(strPlayerIdx,"%d",pPlayerRecord->idx);
static char strIPaddress[tagAddBillPacket::maxbytes_user_ip];
wsprintf(strIPaddress,"%d.%d.%d.%d",
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b1,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b2,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b3,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b4);
Transmite_Game_End(
strPlayerIdx,
pPlayerRecord->userID,
strIPaddress,
pPlayerRecord->AddBill.User_Status);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::
Transmite_User_Sync(
BOOL bExist,
const char* pszPlayerIdx,
const char* pPlayerID,
const char* pIPaddress,
const char* pUser_Status) const
{
static struct tagAddBillPacket Packet;
memset(&Packet,0x00,sizeof(struct tagAddBillPacket));
Packet.Packet_Type = htonl(tagAddBillPacket::packet_type_user_sync);
if(TRUE == bExist) Packet.Packet_Result = htonl(1);
else Packet.Packet_Result = htonl(0);
SetSessionStr(Packet,pszPlayerIdx,pPlayerID);
strncpy(Packet.User_ID,pPlayerID,tagAddBillPacket::maxbytes_user_id);
strncpy(Packet.User_IP,pIPaddress,tagAddBillPacket::maxbytes_user_ip);
strncpy(Packet.User_Status,pUser_Status,tagAddBillPacket::maxbytes_user_status);
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Push(&Packet);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::Transmite_User_Sync(const struct tagAddBillPacket& Packet) const
{
Transmite_User_Sync(
FALSE,
Packet.Session,
Packet.User_ID,
Packet.User_IP,
Packet.User_Status);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Encoder::Transmite_User_Sync(const playerCharacter_t* pPlayerRecord) const
{
static char strPlayerIdx[_MAX_PATH];
wsprintf(strPlayerIdx,"%d",pPlayerRecord->idx);
static char strIPaddress[tagAddBillPacket::maxbytes_user_ip];
wsprintf(strIPaddress,"%d.%d.%d.%d",
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b1,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b2,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b3,
pPlayerRecord->sock.addr.sin_addr.S_un.S_un_b.s_b4);
Transmite_User_Sync(
TRUE,
strPlayerIdx,
pPlayerRecord->userID,
strIPaddress,
pPlayerRecord->AddBill.User_Status);
}
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_RECEIVECIRCUALRQUEUECTRL_H__CAC70141_0F1A_40C4_97EA_44AE33CE941B__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_RECEIVECIRCUALRQUEUECTRL_H__CAC70141_0F1A_40C4_97EA_44AE33CE941B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagAddBill.h"
#include "CTerraBillingCtrl_CircularQueueCtrl.h"
class CTerraBillingCtrl_ReceiveCircualrQueueCtrl : public CTerraBillingCtrl_CircularQueueCtrl
{
private:
BOOL m_bOK;
enum{
MaxBytes_LineBuffer= sizeof(struct tagAddBillPacket) * 2,
};
unsigned char m_LineBuffer[MaxBytes_LineBuffer];
int m_LineBufferStoreBytes;
public:
BOOL isOK(void) const;
BOOL Push(const unsigned char* pNewData,const int NewDataBytes);
public:
CTerraBillingCtrl_ReceiveCircualrQueueCtrl(const int Number);
virtual ~CTerraBillingCtrl_ReceiveCircualrQueueCtrl();
};
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_ENCODER_H__CDF45D1F_C7F7_4963_8751_F14D246399C9__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_ENCODER_H__CDF45D1F_C7F7_4963_8751_F14D246399C9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTerraBillingCtrl_Encoder
{
private:
BOOL m_bOK;
private:
inline void SetSessionStr(struct tagAddBillPacket& Packet,const playerCharacter_t* pPlayer) const;
inline void SetSessionStr(struct tagAddBillPacket& Packet,const char* pszPlayerIdx,const char* pszPlayerID) const;
public:
BOOL isOK(void) const;
void Transmite_Server_Conn(void);
void Transmite_Server_Reset(void);
#ifdef _GAME_SERVER
void Transmite_Game_Start(const playerCharacter_t* pPlayerRecord) const;
void Transmite_Game_End(const playerCharacter_t* pPlayerRecord) const;
void Transmite_Game_End(
const char* pszPlayerIdx,
const char* pPlayerID,
const char* pIPaddress,
const char* pUser_Status) const;
void Transmite_Game_End(const struct tagAddBillPacket& Packet) const;
void Transmite_User_Sync(
BOOL bExist,
const char* pszPlayerIdx,
const char* pPlayerID,
const char* pIPaddress,
const char* pUser_Status) const;
void Transmite_User_Sync(const struct tagAddBillPacket& Packet) const;
void Transmite_User_Sync(const playerCharacter_t* pPlayerRecord) const;
#endif
#ifdef _MASTER_SERVER
public:
void Transmite_Billing_Authorization(const i3client_t* pPlayer);
#endif
public:
CTerraBillingCtrl_Encoder();
virtual ~CTerraBillingCtrl_Encoder();
};
#endif
| C++ |
#include "..\..\global.h"
#include "CTerraBillingCtrl_CircularQueueCtrl.h"
#include <assert.h>
#include <windowsx.h>
CTerraBillingCtrl_CircularQueueCtrl::
CTerraBillingCtrl_CircularQueueCtrl(const int Number)
{
assert(Number > 0);
m_bOK=FALSE;
m_pBuffer=NULL;
m_Number=0;
m_ReadIdx = 0;
m_WriteIdx = 0;
InitializeCriticalSection(&m_critcalsection);
if(FALSE == Init(Number)) return;
m_bOK=TRUE;
}
CTerraBillingCtrl_CircularQueueCtrl::~CTerraBillingCtrl_CircularQueueCtrl()
{
DeleteCriticalSection(&m_critcalsection);
if(NULL != m_pBuffer){ GlobalFreePtr(m_pBuffer); m_pBuffer=NULL; }
}
BOOL CTerraBillingCtrl_CircularQueueCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CTerraBillingCtrl_CircularQueueCtrl::
Init(const int Number)
{
m_Number = Number;
m_pBuffer=(struct tagAddBillPacket*)GlobalAllocPtr(GMEM_FIXED,sizeof(struct tagAddBillPacket) * m_Number);
if(NULL == m_pBuffer) return FALSE;
memset(m_pBuffer,0x00,sizeof(struct tagAddBillPacket) * m_Number);
return TRUE;
}
inline BOOL CTerraBillingCtrl_CircularQueueCtrl::
isEmpty(void) const
{
if(m_ReadIdx == m_WriteIdx) return TRUE;
return FALSE;
}
inline BOOL CTerraBillingCtrl_CircularQueueCtrl::
isFull(void) const
{
int tempWriteIdx = m_WriteIdx;
tempWriteIdx+=1;
if(tempWriteIdx >= m_Number) tempWriteIdx=0;
if(tempWriteIdx == m_ReadIdx) return TRUE;
return FALSE;
}
BOOL CTerraBillingCtrl_CircularQueueCtrl::
Push(const struct tagAddBillPacket* pData)
{
EnterCriticalSection(&m_critcalsection);
if(TRUE == isFull()){
LeaveCriticalSection(&m_critcalsection);
return FALSE;
}
m_pBuffer[m_WriteIdx] = *pData;
m_WriteIdx+=1;
if(m_WriteIdx >= m_Number) m_WriteIdx=0;
LeaveCriticalSection(&m_critcalsection);
return TRUE;
}
BOOL CTerraBillingCtrl_CircularQueueCtrl::
Pop(struct tagAddBillPacket& Data)
{
EnterCriticalSection(&m_critcalsection);
if(TRUE == isEmpty()){
LeaveCriticalSection(&m_critcalsection);
return FALSE;
}
Data = m_pBuffer[m_ReadIdx];
m_ReadIdx+=1;
if(m_ReadIdx >= m_Number) m_ReadIdx=0;
LeaveCriticalSection(&m_critcalsection);
return TRUE;
}
void CTerraBillingCtrl_CircularQueueCtrl::Clear(void)
{
m_ReadIdx=m_WriteIdx=0;
}
| C++ |
#include "../../global.h"
#include "CTerraBillingCtrl_ReceiveCircualrQueueCtrl.h"
CTerraBillingCtrl_ReceiveCircualrQueueCtrl::
CTerraBillingCtrl_ReceiveCircualrQueueCtrl(const int Number):CTerraBillingCtrl_CircularQueueCtrl(Number)
{
m_bOK=FALSE;
if(FALSE == CTerraBillingCtrl_CircularQueueCtrl::isOK()) return;
m_LineBufferStoreBytes=0;
m_bOK=TRUE;
}
CTerraBillingCtrl_ReceiveCircualrQueueCtrl::~CTerraBillingCtrl_ReceiveCircualrQueueCtrl()
{
}
BOOL CTerraBillingCtrl_ReceiveCircualrQueueCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CTerraBillingCtrl_ReceiveCircualrQueueCtrl::
Push(const unsigned char* pNewData,const int NewDataBytes)
{
EnterCriticalSection(&m_critcalsection);
int RemainBytesBeforeCompletePacket=0;
int RemainBytesNewData = NewDataBytes;
unsigned char* pTempInsetStNewData =(unsigned char*)pNewData;
while(TRUE){
RemainBytesBeforeCompletePacket = sizeof(struct tagAddBillPacket) - m_LineBufferStoreBytes;
if(RemainBytesBeforeCompletePacket > RemainBytesNewData){
if(0 == m_LineBufferStoreBytes) memcpy(&m_LineBuffer[0],pTempInsetStNewData,RemainBytesNewData);
else memcpy(&m_LineBuffer[m_LineBufferStoreBytes-1],pTempInsetStNewData,RemainBytesNewData);
m_LineBufferStoreBytes += RemainBytesNewData;
break;
}
if(0 == m_LineBufferStoreBytes) memcpy(&m_LineBuffer[0],pTempInsetStNewData,RemainBytesBeforeCompletePacket);
else memcpy(&m_LineBuffer[m_LineBufferStoreBytes-1],pTempInsetStNewData,RemainBytesBeforeCompletePacket);
if(FALSE == CTerraBillingCtrl_CircularQueueCtrl::Push((struct tagAddBillPacket*)m_LineBuffer)){
LeaveCriticalSection(&m_critcalsection);
return FALSE;
}
pTempInsetStNewData += RemainBytesBeforeCompletePacket;
RemainBytesNewData -= RemainBytesBeforeCompletePacket;
if(RemainBytesNewData <= 0) break;
}
LeaveCriticalSection(&m_critcalsection);
return TRUE;
} | C++ |
#if !defined(AFX_CTERRABILLINGCTRL_H__F366D29E_FA42_4018_8DBA_0A9E735D3184__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_H__F366D29E_FA42_4018_8DBA_0A9E735D3184__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTerraBillingCtrl
{
private:
enum{
MaxNum_TrnamisteCircularQueueEle = 512,
MaxNum_ReceiveCircularQueueEle = 512,
};
BOOL m_bOK;
enum enumStep{
step_none=0,
step_connect_try,
step_transmite_packet_conn_and_reset,
step_service,
step_disconnect_try,
};
enum enumStep m_Step;
private:
BOOL Init(void);
BOOL LoadServerConfigFile(void);
inline void TransmiteAllPacketInTransmiteCircularQueue(void) const;
#ifdef _MASTER_SERVER
public:
inline i3client_t* GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const;
inline void Decoder_billing_authorization(const struct tagAddBillPacket& Packet) const;
#endif
public:
BOOL isOK(void) const;
void Process(void);
inline void Process_step_service(void);
BOOL ServiceStart(void);
void ServiceEnd(void);
static void OpenNotePadMessage(const char* pMessage);
public:
#ifdef _GAME_SERVER
void Player_GameStart(playerCharacter_t* pPlayerRecord);
void Player_GameEnd(playerCharacter_t* pPlayerRecord);
BOOL CheckPlayer(playerCharacter_t* pPlayerRecord);
#endif
public:
CTerraBillingCtrl();
virtual ~CTerraBillingCtrl();
};
#endif
| C++ |
#include "Checksum.h"
void checksum::add(DWORD value)
{
union { DWORD value; BYTE bytes[4]; } data;
data.value = value;
for(UINT i = 0; i < sizeof(data.bytes); i++)
add(data.bytes[i]);
}
void checksum::add(WORD value)
{
union { DWORD value; BYTE bytes[2]; } data;
data.value = value;
for(UINT i = 0; i < sizeof(data.bytes); i++)
add(data.bytes[i]);
}
void checksum::add(BYTE value)
{
BYTE cipher = (value ^ (r >> 8));
r = (cipher + r) * c1 + c2;
sum += cipher;
}
void checksum::add(LPBYTE b, UINT length)
{
for(UINT i = 0; i < length; i++)
add(b[i]);
} | C++ |
#include "../global.h"
void Normalize( float* n )
{
float length;
length = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
length = (float)sqrt(length);
if (length == 0.0f) length = 0.000001f;
n[0] /= length;
n[1] /= length;
n[2] /= length;
}
void RotateXCoord(vec3_t A, float Angle)
{
float c,s;
float tempY, tempZ;
s=sin(DEG2RAD(Angle));
c=cos(DEG2RAD(Angle));
tempY = A[1];
tempZ = A[2];
A[1] = tempY * c - tempZ * s;
A[2] = tempY * s + tempZ * c;
}
void RotateYCoord(vec3_t A, float Angle)
{
float c,s;
float tempX, tempZ;
s=sin(DEG2RAD(Angle));
c=cos(DEG2RAD(Angle));
tempX = A[0];
tempZ = A[2];
A[0] = tempX * c + tempZ * s;
A[2] = tempZ * c - tempX * s;
}
void RotateZCoord(vec3_t A, float Angle)
{
float c,s;
float tempX, tempY;
s=sin(DEG2RAD(Angle));
c=cos(DEG2RAD(Angle));
tempX = A[0];
tempY = A[1];
A[0] = tempX * c - tempY * s;
A[1] = tempX * s + tempY * c;
}
void vectoangles( const vec3_t value1, vec3_t angles )
{
float forward;
float yaw, pitch;
if ( value1[1] == 0 && value1[0] == 0 )
{
yaw = 0;
if ( value1[2] > 0 )
{
pitch = 90;
}
else
{
pitch = 270;
}
}
else {
if ( value1[0] )
{
yaw = ( atan2 ( value1[1], value1[0] ) * 180 / M_PI );
}
else if ( value1[1] > 0 )
{
yaw = 90;
}
else
{
yaw = 270;
}
if ( yaw < 0 ) {
yaw += 360;
}
forward = sqrt ( value1[0]*value1[0] + value1[1]*value1[1] );
pitch = ( atan2(value1[2], forward) * 180 / M_PI );
if ( pitch < 0 )
{
pitch += 360;
}
}
angles[PITCH] = -pitch;
angles[YAW] = yaw;
angles[ROLL] = 0;
}
int GTH_Randomize( int maxGen )
{
double r;
r = genrand_real3();
return( (int)( r * (double)maxGen ) );
}
int GTH_RandomizePower( int minValue, int maxValue )
{
float r;
r = genrand_real3();
r = 1.0f - sqrtf( r );
r = r * ( (float)maxValue - (float)minValue + 1.0f ) + (float)minValue;
return( (int)r );
}
float GTH_Random()
{
return( (float)genrand_real1() );
}
| C++ |
class CTimer
{
int m_stopped;
int m_inited;
int m_usingQPF;
double m_lastElapsedTime;
double m_baseTime;
double m_stopTime;
double m_currSysTime;
double m_currElapsedTime;
double m_baseMilliTime;
double m_currSysMilliTime;
double m_currElapsedMilliTime;
LONGLONG m_QPFTicksPerSec;
LONGLONG m_QPFStopTime;
LONGLONG m_QPFLastElapsedTime;
LONGLONG m_QPFBaseTime;
LARGE_INTEGER m_QPFTime;
public:
CTimer();
virtual ~CTimer();
void Start();
void Stop();
void Advance();
void Reset();
float Tick();
inline float GetAppTime() { return (float) ( m_currSysTime - m_baseTime ); }
inline float GetElapsedTime() { return (float) m_currElapsedTime; }
inline float GetSysTime() { return (float) m_currSysTime; }
inline float GetAppMilliTime() { return (float) ( m_currSysMilliTime - m_baseMilliTime ); }
inline float GetElapsedMilliTime() { return (float) m_currElapsedMilliTime; }
float GetAbsoluteTime();
};
| C++ |
#include "../global.h"
CTimer::CTimer()
{
m_stopped = true;
m_inited = false;
m_usingQPF = false;
m_lastElapsedTime = 0.0;
m_baseTime = 0.0;
m_stopTime = 0.0;
m_currSysTime = 0.0;
m_currElapsedTime = 0.0;
m_baseMilliTime = 0.0;
m_currSysMilliTime = 0.0;
m_currElapsedMilliTime = 0.0;
m_QPFTicksPerSec = 0;
m_QPFStopTime = 0;
m_QPFLastElapsedTime = 0;
m_QPFBaseTime = 0;
}
CTimer::~CTimer()
{
}
void CTimer::Start()
{
if( !m_inited )
{
LARGE_INTEGER qwTicksPerSec;
m_usingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
if( m_usingQPF )
m_QPFTicksPerSec = qwTicksPerSec.QuadPart;
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_QPFBaseTime = m_QPFTime.QuadPart;
m_currSysTime = m_QPFBaseTime / (double) m_QPFTicksPerSec;
m_baseTime = m_currSysTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseMilliTime = m_baseTime * 1000.0;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_baseTime = m_currSysTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseMilliTime = m_baseTime * 1000.0;
}
m_inited = true;
}
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFStopTime = 0;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_stopTime = 0.0f;
m_lastElapsedTime = m_currSysTime;
}
m_stopped = false;
}
void CTimer::Stop()
{
if( m_stopped ) return;
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFStopTime = m_QPFTime.QuadPart;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_stopTime = m_currSysTime;
m_lastElapsedTime = m_currSysTime;
}
m_stopped = true;
}
void CTimer::Advance()
{
if( m_usingQPF )
m_QPFStopTime += m_QPFTicksPerSec / 10;
else
m_stopTime += 0.1f;
}
void CTimer::Reset()
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFBaseTime = m_QPFTime.QuadPart;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
m_QPFStopTime = 0;
m_baseTime = m_QPFBaseTime / (double) m_QPFTicksPerSec;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseTime = m_currSysTime;
m_lastElapsedTime = m_currSysTime;
m_stopTime = 0.0;
}
m_stopped = false;
}
float CTimer::Tick()
{
if( m_stopped )
{
if( m_usingQPF )
{
m_currSysTime = m_QPFStopTime / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
}
else
{
m_currSysTime = m_stopTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
}
}
else
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_currElapsedTime = (double) ( m_QPFTime.QuadPart - m_QPFLastElapsedTime ) / (double) m_QPFTicksPerSec;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_currElapsedTime = (double) ( m_currSysTime - m_lastElapsedTime );
m_lastElapsedTime = m_currSysTime;
m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
}
}
return (float) m_currElapsedTime;
}
float CTimer::GetAbsoluteTime()
{
if( m_stopped )
{
if( m_usingQPF )
{
return (float) ( m_QPFStopTime / (double) m_QPFTicksPerSec );
}
else
{
return (float) ( m_stopTime );
}
}
else
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
return (float) ( m_QPFTime.QuadPart / (double) m_QPFTicksPerSec );
}
else
{
return (float) ( timeGetTime() * 0.001 );
}
}
} | C++ |
#ifndef STRICT
#define STRICT
#endif
#include "mtrand.h"
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL
#define UMASK 0x80000000UL
#define LMASK 0x7fffffffUL
#define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) )
#define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1UL ? MATRIX_A : 0UL))
static unsigned long state[N];
static int left = 1;
static int initf = 0;
static unsigned long *next;
void init_genrand(unsigned long s)
{
int j;
state[0]= s & 0xffffffffUL;
for (j=1; j<N; j++) {
state[j] = (1812433253UL * (state[j-1] ^ (state[j-1] >> 30)) + j);
state[j] &= 0xffffffffUL;
}
left = 1; initf = 1;
}
static void next_state(void)
{
unsigned long *p=state;
int j;
if (initf==0) init_genrand(5489UL);
left = N;
next = state;
for (j=N-M+1; --j; p++)
*p = p[M] ^ TWIST(p[0], p[1]);
for (j=M; --j; p++)
*p = p[M-N] ^ TWIST(p[0], p[1]);
*p = p[M-N] ^ TWIST(p[0], state[0]);
}
unsigned long genrand_int32(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return y;
}
long genrand_int31(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (long)(y>>1);
}
double genrand_real1(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (double)y * (1.0/4294967295.0);
}
double genrand_real2(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (double)y * (1.0/4294967296.0);
}
double genrand_real3(void)
{
unsigned long y;
if (--left == 0) next_state();
y = *next++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return ((double)y + 0.5) * (1.0/4294967296.0);
}
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
| C++ |
#include "../global.h"
char *curpos, *endpos;
byte *tokenBuffer = NULL;
int LoadTokenBuffer( char* filename )
{
FILE *fp;
int size;
if( tokenBuffer != NULL ) DeleteTokenBuffer();
fp = fopen( filename, "rb" );
if( !fp ) return 0;
fseek( fp, 0, SEEK_END );
size = ftell( fp );
tokenBuffer = new byte[size+1];
fseek( fp, 0, SEEK_SET );
fread( tokenBuffer, size, 1, fp );
fclose( fp );
SetTokenBuffer( tokenBuffer, size );
return 1;
}
int DeleteTokenBuffer()
{
delete tokenBuffer;
tokenBuffer = NULL;
return 1;
}
int SetTokenBuffer( byte *buffer , int size )
{
curpos = (char *)buffer;
endpos = curpos + size;
if( size <= 0 )
return false;
return true;
}
char* NextToken()
{
char *token;
while (curpos < endpos)
{
while (*curpos == ' ' || *curpos == '\t' || *curpos == '\n' || *curpos == '\r')
if (++curpos == endpos) return NULL;
if (curpos[0] == '/' && curpos[1] == '/')
{
while ( 1 )
{
if( IsDBCSLeadByte( (BYTE)*curpos ) )
{
curpos += 2;
continue;
}
else if( *curpos++ == '\n' ) break;
if (curpos == endpos) return NULL;
}
continue;
}
token = curpos;
while ( 1 )
{
if( IsDBCSLeadByte( (BYTE)*curpos ) )
{
curpos ++;
}
else if( *curpos == ' ' || *curpos == '\t' || *curpos == '\n' || *curpos == '\r' )
{
break;
}
if (++curpos == endpos) break;
}
*curpos++ = '\0';
return token;
}
return NULL;
}
void NextCVSTokenReturn( char token[], int &endFile )
{
int l = 0;
endFile = 0;
memset( token, 0, sizeof( token ) );
while (curpos < endpos)
{
while (*curpos != '\r' )
{
token[l] = *curpos;
l ++;
curpos ++;
if ( curpos == endpos )
{
endFile = 1;
break;
}
}
if( *curpos == '\r' )
{
curpos ++;
curpos ++;
if ( curpos == endpos )
{
endFile = 1;
break;
}
endFile = 2;
}
else
{
curpos ++;
}
token[l] = '\0';
return;
}
endFile = 1;
return;
}
char* NextArg()
{
char *arg;
while (curpos < endpos)
{
while (*curpos == ' ' || *curpos == '\t')
if (++curpos == endpos) return NULL;
if( *curpos == '\n' || *curpos == '\r' ||
(curpos[0] == '/' && curpos[1] == '/') )
return NULL;
arg = curpos;
while ( 1 )
{
if( IsDBCSLeadByte( (BYTE)*curpos ) )
{
curpos ++;
}
else if( *curpos == ' ' || *curpos == '\t' || *curpos == '\n' || *curpos == '\r' )
{
break;
}
if (++curpos == endpos) break;
}
*curpos++ = '\0';
return arg;
}
return NULL;
}
int NextCSVToken( char token[] )
{
int l = 0;
int ret = 0;
memset( token, 0, sizeof( token ) );
while (curpos < endpos)
{
while ( 1 )
{
if( IsDBCSLeadByte( (BYTE)*curpos ) )
{
token[l] = *curpos; l ++; curpos ++;
token[l] = *curpos; l ++; curpos ++;
}
else if( *curpos == ',' || *curpos == '\r' )
{
break;
}
else if ( curpos == endpos )
{
ret = 1;
break;
}
else
{
token[l] = *curpos; l ++; curpos ++;
}
}
if( *curpos == '\r' )
{
curpos ++;
curpos ++;
if ( curpos == endpos )
{
ret = 1;
break;
}
ret = 2;
}
else
{
curpos ++;
}
token[l] = '\0';
return( ret );
}
ret = 1;
return( ret );
}
| C++ |
#if !defined(AFX_CTOOLS_H__27E5ED11_4334_47F6_80B0_D401A9E1F9D4__INCLUDED_)
#define AFX_CTOOLS_H__27E5ED11_4334_47F6_80B0_D401A9E1F9D4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTools
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
skill_t* GetMySkillTpointer(playerCharacter_t* pPlayer,const int Idx);
playerCharacter_t* GetPlayerRecordPointer(const int Idx);
playerCharacter_t* GetPlayerRecordPointer(const querySet_t& querySet);
playerCharacter_t* GetPlayerRecordPointer(const char* pName);
void IncDecChaosPoint(playerCharacter_t* pPlayer,const int changePoint);
BOOL DeleteItemFromMyInventory(playerCharacter_t* pPlayer,const int iInventoryIdx,const int ItemTableIdx, int DeleteNum = 1);
public:
monsterCharacter_t* GetNPCRecordPointer(const int Idx);
public:
monsterCharacter_t* GetMonsterRecordPointer(const int Idx);
private:
inline BOOL AddItem_Inventory(playerCharacter_t* pPlayer,const int ItemArrayIdx);
inline BOOL AddItem_DropMap(playerCharacter_t* pPlayer,const int ItemArrayIdx);
public:
itemTable_t* GetItemTablePointer(const int Idx);
BOOL IsStackItem(const item_t* pItem);
item_t* GetMyItem(playerCharacter_t* pPlayer,const int ItemIdx);
int AddItem(playerCharacter_t* pPlayer,item_t& item, BOOL bDropItem = TRUE);
int GetMatchMyInventoryIdx_fromItemTable(playerCharacter_t* pPlayer,const int paramItemTableIdx);
BOOL AddItemBatting(playerCharacter_t* pPlayer,item_t& item);
int GetMatchMyItemIdx_fromINVENTORY(playerCharacter_t* pPlayer,const int paramItemTableIdx);
public:
int GetEpkChargeCount(item_t *pItem);
void SetEpkChargeCount(item_t *pItem,int count);
BOOL isSummonAllow(playerCharacter_t* pPlayer);
bool IsTransformEntity( void *ent, int entType );
public:
CTools();
virtual ~CTools();
};
#endif
| C++ |
#include "CTerraBillingCtrl.h"
CTerraBillingCtrl::CTerraBillingCtrl()
{
}
CTerraBillingCtrl::~CTerraBillingCtrl()
{
}
| C++ |
#if !defined(AFX_CPREMIUMPLAYERCTRL_H__630C6208_F656_4AB1_91F4_4BEFF42A5CA3__INCLUDED_)
#define AFX_CPREMIUMPLAYERCTRL_H__630C6208_F656_4AB1_91F4_4BEFF42A5CA3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CPremiumPlayerCtrl
{
public:
enum enumMapIdx{
Ariyan=0,
Light_Lake=1,
Aurora_Canyon=2,
Arth_Crystal_Mine=3,
The_Temple_of_Artzran=4,
Bazmo_Fortress=5,
Illusion_Temple=6,
Dragon_Labyrinth=7,
Dark_Lake=8,
Sien=9,
Sien_Canyon=10,
Sodo=11,
Laznan_Level1=12,
Laznan_Level2=13,
Laznan_Level3=14,
Laznan_Level4=15,
Laznan_Level5=16,
Judgment_Canyon=17,
Temptation_Corridor=18,
Forgetting_Corridor=19,
Dan_Colosseum=20,
Gyorun_Colosseum=21,
};
struct playerCharacter_t::tagPremiumInfo m_PremiumLevelTable[playerCharacter_t::tagPremiumInfo::enumMeberShipType::Max];
private:
BOOL m_bOK;
void Init_PremiumLevelTable_Free(void);
void Init_PremiumLevelTable_Pay(void);
void LoadIniFile(const char* szpIniFileName,struct playerCharacter_t::tagPremiumInfo* pPremium);
void SaveIniFile(const char* szpIniFileName,const struct playerCharacter_t::tagPremiumInfo* pPremium);
public:
BOOL isOK(void) const;
void SetData(enum playerCharacter_t::tagPremiumInfo::enumMeberShipType MemberShipType,playerCharacter_t* pPlayerRecord) const;
BOOL isAccessMap(const int MapIdx,const playerCharacter_t* pPlayerRecord) const;
BOOL LoadIniFile(void);
public:
void Test_SetPremiumPlayerInfo(playerCharacter_t* pPlayerRecord) const;
public:
CPremiumPlayerCtrl();
virtual ~CPremiumPlayerCtrl();
};
#endif
| C++ |
#if !defined(AFX_CGMCTRL_SERVERSTATEDATACTRL_H__69F41670_3750_4092_BDDB_ED407AA1E1E8__INCLUDED_)
#define AFX_CGMCTRL_SERVERSTATEDATACTRL_H__69F41670_3750_4092_BDDB_ED407AA1E1E8__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGMCtrl_ServerStateDataCtrl
{
public:
struct tagState{
public:
struct tagFlag{
public:
struct tagElement{
unsigned int bPK:1;
unsigned int bNProtectAUTH:1;
unsigned int unused:30;
};
public:
union{
unsigned int Value;
struct tagElement Ele;
};
};
public:
struct tagFlag Flag;
};
private:
BOOL m_bOK;
struct tagState m_State;
public:
BOOL isOK(void) const;
void SaveODBC(void);
public:
BOOL isPK(void) const;
void SetPK(const BOOL bPK);
public:
BOOL isNProtectAUTH(void) const;
void SetNProtectAUTH(const BOOL in_bEnable);
public:
void ODBC_ProcessQueryResultQueue_QUERY_LOADSERVERSTATUS(const querySet_t& result);
public:
CGMCtrl_ServerStateDataCtrl();
virtual ~CGMCtrl_ServerStateDataCtrl();
};
#endif
| C++ |
#include "..\global.h"
#include "CGMCtrl.h"
#include "..\CTools.h"
extern CTools* gcpTools;
CGMCtrl::CGMCtrl()
{
m_bOK=FALSE;
m_cpPKTimeCtrl = NULL;
m_cpChatBlockCtrl = NULL;
m_cpServerStateDataCtrl = NULL;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGMCtrl::~CGMCtrl()
{
if(NULL != m_cpPKTimeCtrl){ delete m_cpPKTimeCtrl; m_cpPKTimeCtrl=NULL; }
if(NULL != m_cpChatBlockCtrl){ delete m_cpChatBlockCtrl; m_cpChatBlockCtrl=NULL; }
if(NULL != m_cpServerStateDataCtrl){ delete m_cpServerStateDataCtrl; m_cpServerStateDataCtrl=NULL; }
}
BOOL CGMCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CGMCtrl::Init(void)
{
m_cpServerStateDataCtrl = new CGMCtrl_ServerStateDataCtrl();
if(NULL == m_cpServerStateDataCtrl) return FALSE;
if(FALSE == m_cpServerStateDataCtrl->isOK()){ delete m_cpServerStateDataCtrl; m_cpServerStateDataCtrl=NULL; return FALSE; }
m_cpPKTimeCtrl = new CGMCtrl_PKTimeCtrl(m_cpServerStateDataCtrl);
if(NULL == m_cpPKTimeCtrl) return FALSE;
if(FALSE == m_cpPKTimeCtrl->isOK()){ delete m_cpPKTimeCtrl; m_cpPKTimeCtrl=NULL; return FALSE; }
m_cpChatBlockCtrl = new CGMCtrl_ChatBlockCtrl();
if(NULL == m_cpChatBlockCtrl) return FALSE;
if(FALSE == m_cpChatBlockCtrl->isOK()){ delete m_cpChatBlockCtrl; m_cpChatBlockCtrl=NULL; return FALSE; }
return TRUE;
}
CGMCtrl_ServerStateDataCtrl* CGMCtrl::GetServerStateDataCtrlPointer(void) const
{
return m_cpServerStateDataCtrl;
}
void CGMCtrl::TransmitePacket_NProtect_sc_response_AUTH(playerCharacter_t* pPlayer) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH);
MSG_WriteLong(&netMessage, m_cpServerStateDataCtrl->isNProtectAUTH());
NET_SendMessage( &(pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::TransmitePacket_NProtect_gsms_request_change(const BOOL in_bEnable) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::gsms_request_change);
MSG_WriteLong(&netMessage,in_bEnable);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::TransmitePacket_NProtect_msgs_notify_change(const BOOL in_bEnable) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::msgs_notify_change);
MSG_WriteLong(&netMessage,in_bEnable);
for(int i=1; i < MAX_MEMBER_SERVER; i++){
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::Decoder_NProtect_gsms_request_change(void)
{
BOOL bEnable = MSG_ReadLong();
if(TRUE == bEnable) m_cpServerStateDataCtrl->SetNProtectAUTH(TRUE);
else m_cpServerStateDataCtrl->SetNProtectAUTH(FALSE);
m_cpServerStateDataCtrl->SaveODBC();
TransmitePacket_NProtect_msgs_notify_change(m_cpServerStateDataCtrl->isNProtectAUTH());
}
inline void CGMCtrl::Decoder_NProtect_cs_request_AUTH(playerCharacter_t* pPlayer)
{
BOOL bEnable = MSG_ReadLong();
if(g_config.isManager){
if(NULL == pPlayer) return;
if(0 == GTH_CheckValidation_GameMaster(pPlayer)) return;
if(TRUE == bEnable) m_cpServerStateDataCtrl->SetNProtectAUTH(TRUE);
else m_cpServerStateDataCtrl->SetNProtectAUTH(FALSE);
m_cpServerStateDataCtrl->SaveODBC();
TransmitePacket_NProtect_msgs_notify_change(m_cpServerStateDataCtrl->isNProtectAUTH());
TransmitePacket_NProtect_sc_response_AUTH(pPlayer);
}else{
TransmitePacket_NProtect_gsms_request_change(bEnable);
}
}
void CGMCtrl::TransmitePacket_NProtect_sc_response_AUTH_dll_change(playerCharacter_t* in_pPlayer,const BOOL in_bSuccess,const char* in_strDLLname)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH_dll_change);
MSG_WriteLong(&netMessage,in_bSuccess);
MSG_WriteString(&netMessage,(char*)in_strDLLname);
NET_SendMessage( &(in_pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::Decoder_NProtect_cs_request_AUTH_dll_change(playerCharacter_t* pPlayer)
{
if(NULL == pPlayer) return;
if(0 == GTH_CheckValidation_GameMaster(pPlayer)) return;
char strDLLname[_MAX_PATH];
strncpy(strDLLname,MSG_ReadString(),_MAX_PATH);
}
void CGMCtrl::TransmitePacket_NProtect_sc_response_AUTHstate(playerCharacter_t* in_pPlayer) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTHstate);
MSG_WriteLong(&netMessage, m_cpServerStateDataCtrl->isNProtectAUTH());
NET_SendMessage( &(in_pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::Decoder_NProtect_cs_request_AUTHstate(playerCharacter_t* in_pPlayer)
{
TransmitePacket_NProtect_sc_response_AUTHstate(in_pPlayer);
}
inline void CGMCtrl::Decoder_NProtect_msgs_notify_change(void)
{
BOOL bEnable = MSG_ReadLong();
m_cpServerStateDataCtrl->SetNProtectAUTH(bEnable);
}
void CGMCtrl::Decoder_NProtect(playerCharacter_t* pPlayer)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagNProtect::gsms_request_change:
Decoder_NProtect_gsms_request_change();
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::msgs_notify_change:
Decoder_NProtect_msgs_notify_change();
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTHstate:
Decoder_NProtect_cs_request_AUTHstate(pPlayer);
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTH:
Decoder_NProtect_cs_request_AUTH(pPlayer);
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTH_dll_change:
Decoder_NProtect_cs_request_AUTH_dll_change(pPlayer);
return;
}
}
void CGMCtrl::Decoder(playerCharacter_t* pPlayer)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::GMsystem_NProtect:
Decoder_NProtect(pPlayer);
return;
case tagExtendSecondPacket_GMsystem::GMsystem_ChatBan:
if(NULL == pPlayer) return;
if(!pPlayer->ready) return;
m_cpChatBlockCtrl->Decoder(pPlayer);
return;
case tagExtendSecondPacket_GMsystem::GMsystem_PKtime:
m_cpPKTimeCtrl->Decoder(pPlayer);
return;
}
}
void CGMCtrl::ProcessPerSecond(playerCharacter_t* pPlayer)
{
m_cpChatBlockCtrl->ProcessPerSecond(pPlayer);
}
BOOL CGMCtrl::isPK(void) const
{
return m_cpServerStateDataCtrl->isPK();
}
BOOL CGMCtrl::isNProtectAUTH(void) const
{
return m_cpServerStateDataCtrl->isNProtectAUTH();
}
| C++ |
#include "..\global.h"
#include "CGMCtrl_PKTimeCtrl.h"
#include "..\CTools.h"
extern CTools* gcpTools;
#include <assert.h>
CGMCtrl_PKTimeCtrl::CGMCtrl_PKTimeCtrl(CGMCtrl_ServerStateDataCtrl* cpServerStateDataCtrl)
{
m_bOK=FALSE;
assert(NULL != cpServerStateDataCtrl);
m_cpVirtualServerStateDataCtrl = cpServerStateDataCtrl;
m_bOK=TRUE;
}
CGMCtrl_PKTimeCtrl::~CGMCtrl_PKTimeCtrl()
{
}
BOOL CGMCtrl_PKTimeCtrl::isOK(void) const
{
return m_bOK;
}
inline void CGMCtrl_PKTimeCtrl::TransmitePacket_msgs_notify_change(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::msgs_notify_change);
MSG_WriteLong(&netMessage,m_cpVirtualServerStateDataCtrl->isPK());
for(int i=1; i < MAX_MEMBER_SERVER; i++){
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl_PKTimeCtrl::TransmitePacket_gsms_request_change(const BOOL bPK)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::gsms_request_change);
MSG_WriteLong(&netMessage,bPK);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl_PKTimeCtrl::TransmitePacket_sc_notify_change(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::sc_notify_change);
MSG_WriteLong(&netMessage,m_cpVirtualServerStateDataCtrl->isPK());
playerCharacter_t* pTempPlayer=NULL;
for(int pcIdx = 0; pcIdx < MAX_PCS; pcIdx++ ){
pTempPlayer = gcpTools->GetPlayerRecordPointer(pcIdx);
if(NULL == pTempPlayer) continue;
NET_SendMessage(&pTempPlayer->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl_PKTimeCtrl::Decoder_gsms_request_change(void)
{
if(TRUE == MSG_ReadLong()) m_cpVirtualServerStateDataCtrl->SetPK(TRUE);
else m_cpVirtualServerStateDataCtrl->SetPK(FALSE);
m_cpVirtualServerStateDataCtrl->SaveODBC();
TransmitePacket_sc_notify_change();
TransmitePacket_msgs_notify_change();
}
inline void CGMCtrl_PKTimeCtrl::Decoder_cs_request_change(playerCharacter_t* pPlayer)
{
BOOL bPK=FALSE;
if(TRUE == MSG_ReadLong()) bPK=TRUE;
if(g_config.isManager){
m_cpVirtualServerStateDataCtrl->SetPK(bPK);
m_cpVirtualServerStateDataCtrl->SaveODBC();
TransmitePacket_sc_notify_change();
TransmitePacket_msgs_notify_change();
}else{
TransmitePacket_gsms_request_change(bPK);
}
}
inline void CGMCtrl_PKTimeCtrl::Decoder_msgs_notify_change(void)
{
BOOL bPK=FALSE;
if(TRUE == MSG_ReadLong()) bPK=TRUE;
m_cpVirtualServerStateDataCtrl->SetPK(bPK);
TransmitePacket_sc_notify_change();
}
inline void CGMCtrl_PKTimeCtrl::TransmitePacket_sc_response_status(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::sc_response_status);
MSG_WriteLong(&netMessage, m_cpVirtualServerStateDataCtrl->isPK());
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl_PKTimeCtrl::Decoder_cs_request_status(playerCharacter_t* pPlayer)
{
if(NULL == pPlayer) return;
TransmitePacket_sc_response_status(pPlayer);
}
void CGMCtrl_PKTimeCtrl::Decoder(playerCharacter_t* pPlayer)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagPKtime::cs_request_change:
Decoder_cs_request_change(pPlayer);
break;
case tagExtendSecondPacket_GMsystem::tagPKtime::gsms_request_change:
Decoder_gsms_request_change();
break;
case tagExtendSecondPacket_GMsystem::tagPKtime::msgs_notify_change:
Decoder_msgs_notify_change();
break;
case tagExtendSecondPacket_GMsystem::tagPKtime::cs_request_status:
Decoder_cs_request_status(pPlayer);
break;
}
}
| C++ |
#include "..\global.h"
#include "CGMCtrl_ServerStateDataCtrl.h"
CGMCtrl_ServerStateDataCtrl::CGMCtrl_ServerStateDataCtrl()
{
m_bOK=FALSE;
memset(&m_State,0x00,sizeof(struct tagState));
m_State.Flag.Ele.bPK=FALSE;
m_State.Flag.Ele.bNProtectAUTH=FALSE;
m_bOK=TRUE;
}
CGMCtrl_ServerStateDataCtrl::~CGMCtrl_ServerStateDataCtrl()
{
}
BOOL CGMCtrl_ServerStateDataCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CGMCtrl_ServerStateDataCtrl::isPK(void) const
{
return m_State.Flag.Ele.bPK;
}
void CGMCtrl_ServerStateDataCtrl::SaveODBC(void)
{
g_DBGameServer->SaveServerStatus(m_State.Flag.Value);
}
BOOL CGMCtrl_ServerStateDataCtrl::isNProtectAUTH(void) const
{
return m_State.Flag.Ele.bNProtectAUTH;
}
void CGMCtrl_ServerStateDataCtrl::SetNProtectAUTH(const BOOL in_bEnable)
{
m_State.Flag.Ele.bNProtectAUTH= in_bEnable;
}
void CGMCtrl_ServerStateDataCtrl::SetPK(const BOOL bPK)
{
m_State.Flag.Ele.bPK = bPK;
}
void CGMCtrl_ServerStateDataCtrl::ODBC_ProcessQueryResultQueue_QUERY_LOADSERVERSTATUS(const querySet_t& result)
{
if(result.retCode < 0){
return;
}
m_State.Flag.Value = result.ServerStatus.Value;
}
| C++ |
#include "..\global.h"
#include "CGMCtrl_ChatBlockCtrl.h"
#include "..\CTools.h"
extern CTools* gcpTools;
CGMCtrl_ChatBlockCtrl::CGMCtrl_ChatBlockCtrl()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CGMCtrl_ChatBlockCtrl::~CGMCtrl_ChatBlockCtrl()
{
}
BOOL CGMCtrl_ChatBlockCtrl::isOK(void) const
{
return m_bOK;
}
void CGMCtrl_ChatBlockCtrl::ProcessPerSecond(playerCharacter_t* pPlayer)
{
if(pPlayer->GM.Chat.RemainBanTimePerSecond <= 0) return;
pPlayer->GM.Chat.RemainBanTimePerSecond--;
if(pPlayer->GM.Chat.RemainBanTimePerSecond <= 0){
TransmitePacket_ChatAllow(pPlayer,tagGMPacket_ChatBan_sc_chat_allow::code_by_TimeOut);
}
}
void CGMCtrl_ChatBlockCtrl::
TransmitePacket_ChatAllow(
playerCharacter_t* pPlayer,
const enum tagGMPacket_ChatBan_sc_chat_allow::enumCode code) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_allow);
MSG_WriteLong(&netMessage,code);
NET_SendMessage( &(pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl_ChatBlockCtrl::
TransmitePacket_ChatBlock(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_block);
MSG_WriteLong(&netMessage,pPlayer->GM.Chat.RemainBanTimePerSecond);
NET_SendMessage( &(pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl_ChatBlockCtrl::
TransmitePacket_sc_response_chat_block(
playerCharacter_t* pToPlayer,
const char* szpApplyPlayerName,
const int Time,
const enum tagGMPacket_ChatBan_sc_response_chat_block::enumCode code) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::sc_response_chat_block);
MSG_WriteLong(&netMessage, code);
MSG_WriteString(&netMessage,(char*)szpApplyPlayerName);
MSG_WriteLong(&netMessage,Time);
NET_SendMessage( &(pToPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl_ChatBlockCtrl::TransmitePacket_sc_response_chat_allow(
playerCharacter_t* pToPlayer,
enum tagGMPacket_ChatBan_cs_response_chat_allow::enumCode code,
const char* szpApplyPlayerName) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::sc_response_chat_allow);
MSG_WriteLong(&netMessage, code);
MSG_WriteString(&netMessage,(char*)szpApplyPlayerName);
NET_SendMessage( &(pToPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl_ChatBlockCtrl::Decoder_cs_request_chat_allow(playerCharacter_t* pPlayer)
{
char TargetName[NAMESTRING+1];
strncpy(TargetName,MSG_ReadString(),NAMESTRING);
TargetName[NAMESTRING-1]=NULL;
playerCharacter_t* pTargetPlayer= gcpTools->GetPlayerRecordPointer(TargetName);
if(NULL == pTargetPlayer){
TransmitePacket_sc_response_chat_allow(
pPlayer,
tagGMPacket_ChatBan_cs_response_chat_allow::code_not_find_player,
TargetName);
return;
}
pTargetPlayer->GM.Chat.RemainBanTimePerSecond = 0;
TransmitePacket_ChatAllow(pTargetPlayer,tagGMPacket_ChatBan_sc_chat_allow::code_by_GM);
TransmitePacket_sc_response_chat_allow(
pPlayer,
tagGMPacket_ChatBan_cs_response_chat_allow::code_success,
TargetName);
}
void CGMCtrl_ChatBlockCtrl::Decoder_cs_request_chat_block(playerCharacter_t* pPlayer)
{
char TargetName[NAMESTRING+1];
strncpy(TargetName,MSG_ReadString(),NAMESTRING);
TargetName[NAMESTRING-1]=NULL;
int Time= MSG_ReadLong();
playerCharacter_t* pTargetPlayer= gcpTools->GetPlayerRecordPointer(TargetName);
if(NULL == pTargetPlayer){
TransmitePacket_sc_response_chat_block(
pPlayer,
TargetName,
Time,
tagGMPacket_ChatBan_sc_response_chat_block::enumCode::code_not_find_player);
return;
}
pTargetPlayer->GM.Chat.RemainBanTimePerSecond = Time;
if(pTargetPlayer->GM.Chat.RemainBanTimePerSecond < 0) pTargetPlayer->GM.Chat.RemainBanTimePerSecond=0;
if(pTargetPlayer->GM.Chat.RemainBanTimePerSecond > playerCharacter_t::tagGM::tagChat::max_ban_time) pTargetPlayer->GM.Chat.RemainBanTimePerSecond = playerCharacter_t::tagGM::tagChat::max_ban_time;
TransmitePacket_ChatBlock(pTargetPlayer);
TransmitePacket_sc_response_chat_block(
pPlayer,
pTargetPlayer->name,
pTargetPlayer->GM.Chat.RemainBanTimePerSecond,
tagGMPacket_ChatBan_sc_response_chat_block::enumCode::code_success);
}
void CGMCtrl_ChatBlockCtrl::Decoder_cs_chat_request_reamin_block_time(playerCharacter_t* pPlayer)
{
TransmitePacket_sc_chat_response_reamin_blick_time(pPlayer);
}
void CGMCtrl_ChatBlockCtrl::TransmitePacket_sc_chat_response_reamin_blick_time(playerCharacter_t* pToPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_response_reamin_blick_time);
MSG_WriteLong(&netMessage, pToPlayer->GM.Chat.RemainBanTimePerSecond);
NET_SendMessage( &(pToPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl_ChatBlockCtrl::Decoder(playerCharacter_t* pPlayer)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagChatBan::cs_request_chat_block:
Decoder_cs_request_chat_block(pPlayer);
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::cs_request_chat_allow:
Decoder_cs_request_chat_allow(pPlayer);
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::cs_chat_request_reamin_block_time:
Decoder_cs_chat_request_reamin_block_time(pPlayer);
break;
}
} | C++ |
#if !defined(AFX_CGMCTRL_H__0A3C6621_C407_4361_81A0_8BBB2184D655__INCLUDED_)
#define AFX_CGMCTRL_H__0A3C6621_C407_4361_81A0_8BBB2184D655__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagGMPacket.h"
#include "CGMCtrl_PKTimeCtrl.h"
#include "CGMCtrl_ChatBlockCtrl.h"
#include "CGMCtrl_ServerStateDataCtrl.h"
class CGMCtrl
{
private:
BOOL m_bOK;
public:
CGMCtrl_PKTimeCtrl* m_cpPKTimeCtrl;
CGMCtrl_ChatBlockCtrl* m_cpChatBlockCtrl;
CGMCtrl_ServerStateDataCtrl* m_cpServerStateDataCtrl;
private:
BOOL Init(void);
public:
BOOL isOK(void) const;
void Decoder(playerCharacter_t* pPlayer);
void ProcessPerSecond(playerCharacter_t* pPlayer);
CGMCtrl_ServerStateDataCtrl* GetServerStateDataCtrlPointer(void) const;
BOOL isPK(void) const;
BOOL isNProtectAUTH(void) const;
private:
void Decoder_NProtect(playerCharacter_t* pPlayer);
inline void Decoder_NProtect_cs_request_AUTH(playerCharacter_t* pPlayer);
inline void Decoder_NProtect_cs_request_AUTH_dll_change(playerCharacter_t* pPlayer);
inline void Decoder_NProtect_cs_request_AUTHstate(playerCharacter_t* in_pPlayer);
inline void Decoder_NProtect_msgs_notify_change(void);
inline void Decoder_NProtect_gsms_request_change(void);
inline void TransmitePacket_NProtect_msgs_notify_change(const BOOL in_bEnable) const;
inline void TransmitePacket_NProtect_gsms_request_change(const BOOL in_bEnable) const;
void TransmitePacket_NProtect_sc_response_AUTHstate(playerCharacter_t* in_pPlayer) const;
void TransmitePacket_NProtect_sc_response_AUTH(playerCharacter_t* pPlayer) const;
void TransmitePacket_NProtect_sc_response_AUTH_dll_change(playerCharacter_t* in_pPlayer,const BOOL in_bSuccess,const char* in_strDLLname);
public:
CGMCtrl();
virtual ~CGMCtrl();
};
#endif
| C++ |
#if !defined(AFX_CGMCTRL_PKTIMECTRL_H__4F25DB05_3D18_4CF9_BB10_1EDF9F7EE9AA__INCLUDED_)
#define AFX_CGMCTRL_PKTIMECTRL_H__4F25DB05_3D18_4CF9_BB10_1EDF9F7EE9AA__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGMCtrl_ServerStateDataCtrl.h"
class CGMCtrl_PKTimeCtrl
{
public:
BOOL m_bOK;
CGMCtrl_ServerStateDataCtrl* m_cpVirtualServerStateDataCtrl;
public:
BOOL isOK(void) const;
public:
void Decoder(playerCharacter_t* pPlayer);
inline void Decoder_cs_request_change(playerCharacter_t* pPlayer);
inline void Decoder_gsms_request_change(void);
inline void Decoder_msgs_notify_change(void);
inline void Decoder_cs_request_status(playerCharacter_t* pPlayer);
public:
inline void TransmitePacket_sc_notify_change(void);
inline void TransmitePacket_sc_response_status(playerCharacter_t* pPlayer);
inline void TransmitePacket_gsms_request_change(const BOOL bPK);
inline void TransmitePacket_msgs_notify_change(void);
public:
CGMCtrl_PKTimeCtrl(CGMCtrl_ServerStateDataCtrl* cpServerStateDataCtrl);
virtual ~CGMCtrl_PKTimeCtrl();
};
#endif
| C++ |
#if !defined(AFX_CGMCTRL_CHATBLOCKCTRL_H__E9E8F063_E4AB_4B17_859A_FDDC362B9F95__INCLUDED_)
#define AFX_CGMCTRL_CHATBLOCKCTRL_H__E9E8F063_E4AB_4B17_859A_FDDC362B9F95__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagGMPacket.h"
class CGMCtrl_ChatBlockCtrl
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
public:
void Decoder(playerCharacter_t* pPlayer);
void Decoder_cs_request_chat_block(playerCharacter_t* pPlayer);
void Decoder_cs_request_chat_allow(playerCharacter_t* pPlayer);
void Decoder_cs_chat_request_reamin_block_time(playerCharacter_t* pPlayer);
void ProcessPerSecond(playerCharacter_t* pPlayer);
public:
void TransmitePacket_sc_chat_response_reamin_blick_time(playerCharacter_t* pToPlayer);
void TransmitePacket_ChatBlock(playerCharacter_t* pPlayer);
void TransmitePacket_sc_response_chat_block(
playerCharacter_t* pToPlayer,
const char* szpApplyPlayerName,
const int Time,
const enum tagGMPacket_ChatBan_sc_response_chat_block::enumCode code) const;
void TransmitePacket_sc_response_chat_allow(
playerCharacter_t* pToPlayer,
enum tagGMPacket_ChatBan_cs_response_chat_allow::enumCode code,
const char* szpApplyPlayerName) const;
void TransmitePacket_ChatAllow(
playerCharacter_t* pPlayer,
const enum tagGMPacket_ChatBan_sc_chat_allow::enumCode code) const;
public:
CGMCtrl_ChatBlockCtrl();
virtual ~CGMCtrl_ChatBlockCtrl();
};
#endif
| C++ |
#ifndef _CGONRYUNPRACTICE_WAITERCTRL_H_
#define _CGONRYUNPRACTICE_WAITERCTRL_H_
#include <List>
using namespace std;
class CGonryunPracticeBattle;
class CGonryunPractice_ProcessCtrl;
#include "tagGonryunPractice.h"
class CGonryunPractice_WaiterCtrl {
public:
enum _define{
WAIT_MAX_USER_COUNT = 20,
};
typedef std::list<struct tagGPWaitUser> WAIT_USER;
typedef WAIT_USER::iterator WAIT_ITOR;
WAIT_USER m_WaitUserList;
private:
CGonryunPractice_ProcessCtrl* m_cpVirtualProcessCtrl;
BOOL m_bOK;
public:
CGonryunPractice_WaiterCtrl();
virtual ~CGonryunPractice_WaiterCtrl();
public:
BOOL isOK(void);
void Set( CGonryunPracticeBattle* pPracticeBattle);
void Insert(const struct tagGPWaitUser& WaitUser);
void Delete(playerCharacter_t* pPlayer);
void DeleteAll(void);
BOOL Find(struct tagGPWaitUser& Waiter,const char* szpFindPlayerName);
int GetNum(void);
playerCharacter_t* GetWaiter(const struct tagGPWaitUser& Waiter) const;
};
#endif | C++ |
#ifndef _CGONRYUNPRACTICE_ABILITY_H_
#define _CGONRYUNPRACTICE_ABILITY_H_
# include <string>
using namespace std;
class CGonryunPractice_Ability{
public:
CGonryunPractice_Ability();
CGonryunPractice_Ability(const CGonryunPractice_Ability& rReword);
virtual ~CGonryunPractice_Ability(){}
CGonryunPractice_Ability& operator = (const CGonryunPractice_Ability& rReword);
public:
void SetID(const int& id);
const int& GetID()const;
BOOL SetName(const char* pname);
const char* GetName()const;
void SetType(const int& type);
const int& GetType()const;
void SetExperience(const int& Experience);
const int& GetExperience()const;
void SetExpRate(const int& ExpRate);
const int& GetExpRate()const;
void SetItemID(const int& itemID);
const int& GetItemID()const;
void SetItemRate(const int& itemRate);
const int& GetItemRate()const;
private:
BOOL IsvalidNameLength(const char* pname)const;
void Init();
public:
enum _define{
NAMEARRAY = 20,
};
private:
int m_irewordID;
char m_szrewordName[NAMEARRAY+1];
int m_irewordType;
int m_irewordExperience;
int m_irewordExperienceRate;
int m_irewordItemID;
int m_irewordItemRate;
};
#endif | C++ |
#include "..\global.h"
#include "CGonryunPractice_RewordCtrl.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_Ability.h"
#include "CGonryunPractice_RewordItem.h"
#include "CGonryunPractice_Encoder.h"
#include "..\Tools\CTools.h"
extern void GTH_PC_ExpUp( int idx, __int64 &exp, __int64 &genExp, int &lootNSE, int &level, int &genLevel );
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
extern CTools* gcpTools;
CGonryunPractice_RewordCtrl::CGonryunPractice_RewordCtrl()
{
m_bOK=FALSE;
m_cpVirtualProcessCtrl = NULL;
m_cpVirtualEncoder = NULL;
m_bOK=TRUE;
}
CGonryunPractice_RewordCtrl::~CGonryunPractice_RewordCtrl()
{
Destroy();
}
BOOL CGonryunPractice_RewordCtrl::isOK(void)
{
return m_bOK;
}
void CGonryunPractice_RewordCtrl::Set(CGonryunPracticeBattle* pPracticeBattle)
{
m_cpVirtualProcessCtrl = pPracticeBattle->GetProcessCtrl();
m_cpVirtualEncoder = pPracticeBattle->GetEncoder();
}
void CGonryunPractice_RewordCtrl::Destroy(void)
{
for_each(m_rewordItemList.begin(),m_rewordItemList.end(),TDelete<CGonryunPractice_RewordItem>());
m_rewordItemList.clear();
for_each(m_rewordList.begin(),m_rewordList.end(),TDelete<CGonryunPractice_Ability>());
m_rewordList.clear();
}
CGonryunPractice_Ability* CGonryunPractice_RewordCtrl::GetReword(const int Idx)
{
REWORD_ITOR iLoop;
CGonryunPractice_Ability* pReword = NULL;
for( iLoop = m_rewordList.begin(); iLoop!=m_rewordList.end(); iLoop++ ) {
pReword=(CGonryunPractice_Ability*)(*iLoop);
if (pReword->GetID() == Idx){
return pReword;
}
}
return NULL;
}
void CGonryunPractice_RewordCtrl::rewordField(playerCharacter_t* puser)
{
CGonryunPractice_Ability* pReword= NULL;
switch(puser->worldIdx) {
case CGonryunPractice_ProcessCtrl::ARAYANWORLDMAP:
pReword = GetReword(1);
break;
case CGonryunPractice_ProcessCtrl::SYENWORDMAP:
pReword = GetReword(2);
break;
default:
GTH_DisconnectPlayer(puser,FALSE);
return;
}
if ( NULL == pReword ) {
ShowLogInfo("Reward Fail______________");
return;
}
float rewordExperiencePay=0.0f;
float rewordItemRatePay=0.0f;
if( puser->PremiumInfo.iMemberShipType == playerCharacter_t::tagPremiumInfo::Pay ){
rewordExperiencePay = pReword->GetExperience()*g_logic.PCBGonryunCondition.fExpRate;
rewordItemRatePay = pReword->GetItemRate()*g_logic.PCBGonryunCondition.fItemRate;
} else {
rewordExperiencePay = pReword->GetExperience();
rewordItemRatePay = pReword->GetExpRate();
}
float value = rewordExperiencePay/10000.0f;
int GiveExp = g_expTable[puser->level-1].exp*value;
int GiveGenExp = g_expTable[puser->genLevel-1].genExp*(value/2.0f);
ShowLogInfo("Reqward Exp Value : %d, GenExp : %d, value : %d",GiveExp,GiveGenExp,int(value*100));
float frandValue = GTH_Random();
float ExpGiveRate = pReword->GetExpRate()/100.0f;
ShowLogInfo(
"Exp Reword Rand Value : %d, GiveRate : %d,Freemeum : %d ",
int(frandValue*100),
int(ExpGiveRate*100),
puser->PremiumInfo.iMemberShipType);
if ( frandValue <= ExpGiveRate) {
GetLootByBattleReword( puser,GiveExp, GiveGenExp );
}
frandValue = GTH_Random();
float ItemGiveRate = rewordItemRatePay/100.0f;
ShowLogInfo("Item Reword Rand Value : %d, GiveRate : %d",int(frandValue*100),int(ItemGiveRate*100));
if ( frandValue <= ItemGiveRate) {
addItemBattle(puser);
}
}
BOOL CGonryunPractice_RewordCtrl::addItemBattle(playerCharacter_t* puser)
{
int rewardIdx=0;
switch(puser->worldIdx) {
case CGonryunPractice_ProcessCtrl::ARAYANWORLDMAP:
rewardIdx = 1;
break;
case CGonryunPractice_ProcessCtrl::SYENWORDMAP:
rewardIdx = 2;
break;
default:
GTH_DisconnectPlayer(puser,FALSE);
return FALSE;
}
float frandValue = GTH_Random()*100.0f;
CGonryunPractice_RewordItem* pitem = NULL;
float sumValue = 0.0f;
int addItemData[4];
REWORDITEM_ITOR iLoop ;
for( iLoop = m_rewordItemList.begin(); iLoop!=m_rewordItemList.end(); iLoop++ )
{
pitem=(CGonryunPractice_RewordItem*)(*iLoop);
if ( pitem->GetItemIndex() != rewardIdx )
continue;
if ( sumValue <= frandValue && (pitem->GetItemRate()+sumValue) >= frandValue ){
itemTable_t* pItemTable = NULL;
pItemTable = gcpTools->GetItemTablePointer( pitem->GetItemNumber() );
if(NULL == pItemTable){
return FALSE;
}
if( puser->curItemWeight + pItemTable->weight > puser->calItemWeight ){
m_cpVirtualEncoder->SendBattleMsg(
puser,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::Weight_Over);
return FALSE;
}
for(int InventoryIdx = 0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if( 0 > puser->item[InventoryIdx].itemTableIdx) break;
}
if( MAX_INVENTORY_SIZE <= InventoryIdx ) {
m_cpVirtualEncoder->SendBattleMsg(
puser,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::NotEnough_InventorySpace);
return FALSE;
}
if( pItemTable->stackFlag ){
for(InventoryIdx=0; InventoryIdx < MAX_INVENTORY_SIZE; InventoryIdx++){
if(puser->item[InventoryIdx].itemTableIdx != pItemTable->idx) continue;
int numberIdx = puser->item[InventoryIdx].durability + pitem->GetItemCount();
if(numberIdx >= MAX_COUNT_STACK_ITEM) {
m_cpVirtualEncoder->SendBattleMsg(
puser,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::NotEnough_InventorySpace);
return FALSE;
}
break;
}
}
addItemData[0]=pitem->GetItemNumber();
addItemData[1]=-1;
addItemData[2]=pitem->GetItemCount();
addItemData[3] =1;
ShowLogInfo("Reward Item ,No :%d, Count : %d",pitem->GetItemNumber(),pitem->GetItemCount());
addItemBattleField(puser, addItemData);
break;
}
sumValue=sumValue+pitem->GetItemRate();
}
return TRUE;
}
void CGonryunPractice_RewordCtrl::GetLootByBattleReword(playerCharacter_t* pPlayer, __int64 exp,__int64 genExp)
{
int lootNSE=0;
int upFlag = FALSE;
int level = 0, genLevel = 0;
int skillIdx[50], skillNumber = 0;
exp = (__int64)( exp * g_logic.expRate );
genExp = (__int64)( genExp * g_logic.expRate );
if( exp < 0 ) exp = 0;
if( exp == 0 )
return;
GTH_PC_ExpUp( pPlayer->idx, exp, genExp, lootNSE, level, genLevel );
if( level > pPlayer->level )
{
pPlayer->bonusStatusPoint += ( level - pPlayer->level );
GTH_PC_LevelUp(pPlayer, level );
upFlag = true;
}
if( genLevel > pPlayer->genLevel )
{
GTH_PC_GenLevelUp( pPlayer, genLevel );
upFlag = true;
}
if( upFlag )
{
GTH_PC_Calculate( pPlayer, PCINFO_BASIC );
GTH_SendPCMessage_LevelUp(
pPlayer, pPlayer->exp,pPlayer->genExp, pPlayer->curChargeSE, pPlayer->genCapability[ pPlayer->selectedGen], skillIdx, skillNumber, 1 );
}
else
{
GTH_SendMessage_LootValue(
pPlayer, pPlayer->exp, pPlayer->genExp, pPlayer->curChargeSE, pPlayer->genCapability[ pPlayer->selectedGen], 4 );
}
}
void CGonryunPractice_RewordCtrl::ExpUp_Player(playerCharacter_t* pPlayer, int& exp, int& genExp, int& level, int& genLevel)
{
if( (pPlayer->level < LEVEL_THIRTY) && (exp > g_expTable[LEVEL_THIRTY-1].exp)){
exp = g_expTable[LEVEL_THIRTY-1].exp;
} else if((pPlayer->level >= LEVEL_THIRTY) && (exp > g_expTable[pPlayer->level-1].exp) ){
exp = g_expTable[pPlayer->level-1].exp;
}
if( exp > 0 ) {
pPlayer->exp = pPlayer->exp + exp;
level = GTH_GetNextLevel( pPlayer->exp );
}
if((pPlayer->genLevel < LEVEL_FIFTEEN) && (genExp > g_expTable[LEVEL_FIFTEEN-1].genExp)){
genExp = g_expTable[LEVEL_FIFTEEN-1].genExp;
} else if((pPlayer->genLevel >= LEVEL_FIFTEEN) && (genExp > g_expTable[pPlayer->genLevel-1].genExp)){
genExp = g_expTable[pPlayer->genLevel-1].genExp;
}
if( genExp > 0 ) {
pPlayer->genExp = pPlayer->genExp + genExp;
genLevel = GTH_GetNextGenLevel( pPlayer->genExp );
}
}
void CGonryunPractice_RewordCtrl::addItemBattleField( void* pPc, int* pParam )
{
AI_NPC_AddItem(pPc,pParam);
}
CGonryunPractice_ProcessCtrl* CGonryunPractice_RewordCtrl::GetProcessCtrl()
{
return m_cpVirtualProcessCtrl;
}
CGonryunPractice_RewordCtrl::REWORDITEMLIST& CGonryunPractice_RewordCtrl::GetRewordItemList()
{
return m_rewordItemList;
}
CGonryunPractice_RewordCtrl::REWORDLIST& CGonryunPractice_RewordCtrl::GetRewordList()
{
return m_rewordList;
}
| C++ |
#include "..\global.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "CGonryunPractice_RewordCtrl.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPractice_Decoder.h"
#include "CGonryunPractice_Encoder.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
CGonryunPracticeBattle::CGonryunPracticeBattle()
{
m_bOK=FALSE;
m_cpWaiterCtrl=NULL;
m_cpRewordCtrl=NULL;
m_cpDecoder =NULL;
m_cpEncoder = NULL;
m_cpProcessCtrl =NULL;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGonryunPracticeBattle::~CGonryunPracticeBattle()
{
if( NULL != m_cpProcessCtrl){ delete m_cpProcessCtrl; m_cpProcessCtrl = NULL;}
if( NULL != m_cpWaiterCtrl){ delete m_cpWaiterCtrl; m_cpWaiterCtrl = NULL; }
if( NULL != m_cpRewordCtrl){ delete m_cpRewordCtrl; m_cpRewordCtrl = NULL; }
if( NULL != m_cpDecoder){ delete m_cpDecoder; m_cpDecoder = NULL; }
if( NULL != m_cpEncoder){ delete m_cpEncoder; m_cpEncoder = NULL; }
}
BOOL CGonryunPracticeBattle::Init(void)
{
m_cpWaiterCtrl = new CGonryunPractice_WaiterCtrl();
if(NULL == m_cpWaiterCtrl) return FALSE;
if(FALSE == m_cpWaiterCtrl->isOK()){ delete m_cpWaiterCtrl; m_cpWaiterCtrl=NULL; return FALSE; }
m_cpRewordCtrl = new CGonryunPractice_RewordCtrl();
if(NULL == m_cpRewordCtrl) return FALSE;
if(FALSE == m_cpRewordCtrl->isOK()){ delete m_cpRewordCtrl; m_cpRewordCtrl=NULL; return FALSE; }
m_cpDecoder = new CGonryunPractice_Decoder();
if(NULL == m_cpDecoder) return FALSE;
if(FALSE == m_cpDecoder->isOK()){ delete m_cpDecoder; m_cpDecoder=NULL; return FALSE;}
m_cpEncoder = new CGonryunPractice_Encoder();
if(NULL== m_cpEncoder) return FALSE;
if(FALSE == m_cpEncoder->isOK()){ delete m_cpEncoder; m_cpEncoder=NULL; return FALSE; }
m_cpProcessCtrl = new CGonryunPractice_ProcessCtrl();
if(NULL == m_cpProcessCtrl) return FALSE;
if(FALSE == m_cpProcessCtrl->isOK()){ delete m_cpProcessCtrl; m_cpProcessCtrl=NULL; return FALSE; }
m_cpWaiterCtrl->Set(this);
m_cpRewordCtrl->Set(this);
m_cpDecoder->Set(this);
m_cpEncoder->Set(this);
m_cpProcessCtrl->Set(this);
return TRUE;
}
CGonryunPractice_RewordCtrl* CGonryunPracticeBattle::GetRewordCtrl(void)
{
return m_cpRewordCtrl;
}
CGonryunPractice_ProcessCtrl* CGonryunPracticeBattle::GetProcessCtrl(void)
{
return m_cpProcessCtrl;
}
CGonryunPractice_WaiterCtrl* CGonryunPracticeBattle::GetWaiterCtrl(void)
{
return m_cpWaiterCtrl;
}
CGonryunPractice_Encoder* CGonryunPracticeBattle::GetEncoder(void)
{
return m_cpEncoder;
}
CGonryunPractice_Decoder* CGonryunPracticeBattle::GetDecoder(void)
{
return m_cpDecoder;
}
int CGonryunPracticeBattle::NPCClick(playerCharacter_t* pPlayer)
{
if(FALSE == m_cpProcessCtrl->GetActive()){
m_cpEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_NotUse);
return 0;
}
switch(m_cpProcessCtrl->GetStep()){
case CGonryunPractice_ProcessCtrl::STEP_NONE:
break;
case CGonryunPractice_ProcessCtrl::STEP_SUGGUEST:
{
int waitercount = m_cpWaiterCtrl->GetNum()+1;
if( waitercount >= CGonryunPractice_ProcessCtrl::MAX_WAIT_USER ){
m_cpEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::overflow_user_number);
return 0;
}
}
break;
default:
m_cpEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_NotUse);
return 0;
}
switch( pPlayer->worldIdx ){
case CGonryunPractice_ProcessCtrl::ARAYANWORLDMAP:
if((pPlayer->level < g_logic.PCBGonryunCondition.m_iminiLevel) ||
(pPlayer->level > g_logic.PCBGonryunCondition.m_imaxLevel)){
m_cpEncoder->SendBattleMsg(pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::missmatch_user_level,
g_logic.PCBGonryunCondition.m_iminiLevel,
g_logic.PCBGonryunCondition.m_imaxLevel);
return 0;
}
break;
case CGonryunPractice_ProcessCtrl::SYENWORDMAP:
if( (pPlayer->level < g_logic.PCBGonryunCondition.m_isyenminilevel ) ||
(pPlayer->level > g_logic.PCBGonryunCondition.m_isyenmaxlevel)){
m_cpEncoder->SendBattleMsg(pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::missmatch_user_level,
g_logic.PCBGonryunCondition.m_isyenminilevel,
g_logic.PCBGonryunCondition.m_isyenmaxlevel);
return 0;
}
break;
default:
GTH_DisconnectPlayer(pPlayer,FALSE);
return 0;
}
if( pPlayer->curChargeSE < g_logic.PCBGonryunCondition.m_iroyalty ) {
m_cpEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::not_enoughf_nak,
g_logic.PCBGonryunCondition.m_iroyalty);
return 0;
}
time_t lCurrentTime;
struct tm CurrentDate_tm, SaveDate_tm;
time(&lCurrentTime);
CurrentDate_tm = *localtime(&lCurrentTime);
SaveDate_tm = *localtime(&pPlayer->PremiumInfo.GonyounPracticeBattle.lDateV2);
if( CurrentDate_tm.tm_year != SaveDate_tm.tm_year ||
CurrentDate_tm.tm_mon != SaveDate_tm.tm_mon ||
CurrentDate_tm.tm_mday != SaveDate_tm.tm_mday) {
pPlayer->PremiumInfo.GonyounPracticeBattle.lDateV2 = lCurrentTime;
pPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount =
pPlayer->PremiumInfo.GonyounPracticeBattle.iMaxCount;
}
if( 0 >= pPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount ){
m_cpEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::overflow_oneday_use_count,
pPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
return 0;
}
if(FALSE == m_cpProcessCtrl->SuggestPlayer(pPlayer)){
m_cpEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return 0;
}
m_cpEncoder->SendMessage_Open(pPlayer);
return 1;
}
| C++ |
#ifndef _CGONRYUNPRACTICE_DECODER_H_
#define _CGONRYUNPRACTICE_DECODER_H_
class CGonryunPracticeBattle;
class CGonryunPractice_Encoder;
class CGonryunPractice_Decoder;
class CGonryunPractice_ProcessCtrl;
class CGonryunPractice_WaiterCtrl;
class CGonryunPractice_Decoder{
private:
BOOL m_bOK;
public:
CGonryunPractice_Decoder();
virtual ~CGonryunPractice_Decoder();
public:
BOOL isOK(void);
void recvPacket(void);
void Set(CGonryunPracticeBattle* pPracticeBattle);
private:
void recvRespond_NormalResult_fromOpenent(playerCharacter_t* pOpenentPlayer);
void recvReques_NormalBattle_FromLeader(playerCharacter_t* pLeaderPlayer);
void recvRespond_CancelBattle_fromOpenent(playerCharacter_t* pOpenentPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REQUEST(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ADMIT(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_EXIT(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ITEM(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_OK(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CANCEL(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_SE(playerCharacter_t* pPlayer);
void recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REJECT(playerCharacter_t* pPlayer);
void recPaketProcces_BATTEL_PRACTICE_GET_CANCEL(void);
void recPaketProcces_BATTLE_PRACTICE_REQUEST_BATTELGENERATE(void);
void recPaketProcces_BATTLE_PRACTICE_GENERATE_RESULT(void);
void recPaketProcces_BATTLE_PRACTICE_BAN(void);
void recPaketProcces_BATTLE_PRACTICE_START(playerCharacter_t* pPlayer);
void recPatketProcces_BATTLE_PRACTICE_POSITION(playerCharacter_t* pPlayer);
void recPatketProcces_BATTLE_PRACTICE_FAILADDITEM(playerCharacter_t* pPlayer);
void recPatketProcces_BanBattingBattle(void);
void recPatketProcces_CancelBattingBattle(void);
private:
CGonryunPracticeBattle* m_cpVirtualPracticeBattle;
CGonryunPractice_Encoder* m_cpVirtualEncoder;
CGonryunPractice_ProcessCtrl* m_cpVirtualProcessCtrl;
CGonryunPractice_WaiterCtrl* m_cpVirtualWaiterCtrl;
};
#endif
| C++ |
#include "..\global.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CGonryunPractice_WaiterCtrl::CGonryunPractice_WaiterCtrl()
{
m_bOK=FALSE;
m_cpVirtualProcessCtrl = NULL;
m_bOK=TRUE;
}
CGonryunPractice_WaiterCtrl::~CGonryunPractice_WaiterCtrl()
{
}
BOOL CGonryunPractice_WaiterCtrl::isOK(void)
{
return m_bOK;
}
void CGonryunPractice_WaiterCtrl::DeleteAll(void)
{
WAIT_ITOR itor;
struct tagGPWaitUser tempWaiter;
playerCharacter_t* pPlayer = NULL;
for (itor=m_WaitUserList.begin(); itor != m_WaitUserList.end(); itor++){
tempWaiter = *itor;
pPlayer = GetWaiter(tempWaiter);
if( NULL == pPlayer ) continue;
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
pPlayer->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pPlayer->busyState = BUSY_STATE_NONE;
}
m_WaitUserList.clear();
}
void CGonryunPractice_WaiterCtrl::Delete(playerCharacter_t* pPlayer)
{
WAIT_ITOR itor;
struct tagGPWaitUser tempWaiter;
playerCharacter_t* pComparePlayer = NULL;
for (itor=m_WaitUserList.begin();itor != m_WaitUserList.end(); ){
tempWaiter = *itor;
pComparePlayer = GetWaiter(tempWaiter);
if( (NULL == pComparePlayer) || (pPlayer != pComparePlayer)){
itor++;
continue;
}
m_WaitUserList.erase(itor++);
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
pPlayer->busyState = BUSY_STATE_NONE;
break;
}
}
void CGonryunPractice_WaiterCtrl::Insert(const struct tagGPWaitUser& WaitUser)
{
m_WaitUserList.push_back(WaitUser);
}
void CGonryunPractice_WaiterCtrl::Set( CGonryunPracticeBattle* pPracticeBattle)
{
m_cpVirtualProcessCtrl = pPracticeBattle->GetProcessCtrl();
}
playerCharacter_t* CGonryunPractice_WaiterCtrl::GetWaiter(const struct tagGPWaitUser& Waiter)const
{
playerCharacter_t* pPlayer= gcpTools->GetPlayerRecordPointer(Waiter.pcIdx);
if(NULL == pPlayer) return NULL;
if(NULL != strncmp(Waiter.Name,pPlayer->name,NAMESTRING)) return NULL;
if(NULL != strncmp(Waiter.ID,pPlayer->userID,IDSTRING)) return NULL;
return pPlayer;
}
int CGonryunPractice_WaiterCtrl::GetNum(void)
{
return m_WaitUserList.size();
}
BOOL CGonryunPractice_WaiterCtrl::Find(struct tagGPWaitUser& Waiter,const char* szpFindPlayerName)
{
WAIT_ITOR itor;
struct tagGPWaitUser tempWaiter;
for (itor=m_WaitUserList.begin(); itor != m_WaitUserList.end(); itor++){
tempWaiter = (*itor);
if(0 == strncmp(szpFindPlayerName,tempWaiter.Name,NAMESTRING)){
Waiter=tempWaiter;
return TRUE;
}
}
return FALSE;
}
| C++ |
#ifndef _CGONRYUNPRACTICE_ENCODER_H_
#define _CGONRYUNPRACTICE_ENCODER_H_
class CGonryunPracticeBattle;
class CGonryunPractice_ProcessCtrl;
class CGonryunPractice_WaiterCtrl;
#include "tagGonryunPracticePacket.h"
class CGonryunPractice_Encoder
{
private:
BOOL m_bOK;
public:
CGonryunPractice_Encoder();
virtual ~CGonryunPractice_Encoder();
public:
BOOL isOK(void);
void Set(CGonryunPracticeBattle* pPracticeBattle);
void SendEffect(playerCharacter_t* pPlayer,int type);
void SendStatus(playerCharacter_t* pPlayer);
void SendGonryunBattleInfo(playerCharacter_t* pPlayer,const int time);
void SendGonryunBattleResult(playerCharacter_t* pPlayer,int result,char* pname);
void SendMessageBattleReject(playerCharacter_t* pLeaderPlayer);
void SendReqeust_NomalBattle_toOpenent(
const int LeaderPCIdx,
char* szpLeaderName,
playerCharacter_t* pOpenentPlayer);
void SendMessage_NormalReject_toPlayer(playerCharacter_t* pLeaderPlayer);
void SendBattleMsg(
playerCharacter_t* pPlayer,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::enumCode Code,
const int Value1=0,
const int Value2=0,
const int Value3=0) const;
void SendMessageNake(playerCharacter_t* pPlayer);
void SendWaitUserList(playerCharacter_t* pLeaderPlayer,playerCharacter_t* pToPlayer);
void SendMyInfoToUser( playerCharacter_t* pLeaderPlayer,playerCharacter_t* pSuggestPlayer);
void SendDeleteUser(playerCharacter_t* pPlayer);
void SendWaitUserBattleEnd(playerCharacter_t* pPlayer);
void SendWaitUserBattleEnd(void);
void SendMessage_BattingTrade_ItemBatting(
playerCharacter_t* pPlayer,
BOOL bMyItem,
enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::enumType Type,
int pos,
item_t *item,
const int DeleteItemIdx = 0);
void SendMessage_BattingTrade_AdmitBatting( playerCharacter_t* pc);
void SendMessage_BattingTrade_RequestBatting( playerCharacter_t* pPlayer,playerCharacter_t* ptarget, int type );
void SendMessage_BattingTrade_RejectBatting( playerCharacter_t* pc, int type );
void SendMessage_BattingTrade_ExitBatting( playerCharacter_t* pc );
void SendMessage_BattingTrade_OkBatting( playerCharacter_t* pc,BOOL type );
void SendMessage_BattingTrade_CancelBatting( playerCharacter_t* pc, int type );
void SendMessage_BattingTrade_ConfirmBatting(
playerCharacter_t* player,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::enumState& state,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode& Code);
void SendMessage_BattingTrade_SEBatting( playerCharacter_t *pc, int error, int type, int se );
void SendMessage_Open(playerCharacter_t* pPlayer);
int SendPCEventMessage_DieGonryun( playerCharacter_t* pPlayer );
private:
CGonryunPracticeBattle* GetPracticeBattlePointer()const;
CGonryunPractice_ProcessCtrl* GetProcessCtrl()const;
private:
CGonryunPracticeBattle* m_cpVirtualPracticeBattle;
CGonryunPractice_ProcessCtrl* m_cpVirtualProcessCtrl;
CGonryunPractice_WaiterCtrl* m_cpVirtualWaiterCtrl;
};
#endif
| C++ |
#ifndef _CGONRYUNPRACTICE_REWORDITEM_H_
#define _CGONRYUNPRACTICE_REWORDITEM_H_
class CGonryunPractice_RewordItem{
public:
CGonryunPractice_RewordItem();
CGonryunPractice_RewordItem(const CGonryunPractice_RewordItem& rRewordItem);
virtual ~CGonryunPractice_RewordItem()
{
}
CGonryunPractice_RewordItem& operator=(const CGonryunPractice_RewordItem& rRewordItem);
public:
void SetItemIndex(const int& index);
const int& GetItemIndex()const;
void SetItemType(const int& type);
const int& GetItemType()const;
void SetItemNumber(const int& number);
const int& GetItemNumber()const;
void SetItemRate(const int& rate);
const int& GetItemRate()const;
void SetItemCount(const int& count);
const int& GetItemCount()const;
private:
void Init();
private:
int m_irewordItemIndex;
int m_irewordItemType;
int m_irewordItemNumber;
int m_irewordItemRate;
int m_irewordItemCount;
};
#endif | C++ |
#include "..\global.h"
#include "CGonryunPractice_Decoder.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPractice_Encoder.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
void CGonryunPractice_Decoder::recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))){
return;
}
if((pPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER) &&
(pPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT)){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int TargetIdx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer= gcpTools->GetPlayerRecordPointer(TargetIdx);
if(NULL == pTargetPlayer){
GTH_DisconnectPlayer( pPlayer,FALSE );
return;
}
if(FALSE == pTargetPlayer->GonryunBattlePractice.bBattingAdmitSignal){
pPlayer->GonryunBattlePractice.bBattingAdmitSignal = TRUE;
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pTargetPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Admit,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success );
return;
}
playerCharacter_t* pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_cpVirtualProcessCtrl->m_Leader);
playerCharacter_t* pOpponentPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_cpVirtualProcessCtrl->m_Openent);
if( ( NULL == pLeaderPlayer ) && ( NULL == pOpponentPlayer ) ){
m_cpVirtualProcessCtrl->Init();
return;
}
if( NULL == pLeaderPlayer ){
m_cpVirtualProcessCtrl->IrregularQuitBattle(pOpponentPlayer);
return;
}
if(NULL == pOpponentPlayer ){
m_cpVirtualProcessCtrl->IrregularQuitBattle(pLeaderPlayer);
return;
}
{
enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode Leader_code =
m_cpVirtualProcessCtrl->CheckConfirmTradeBatting(pLeaderPlayer,pOpponentPlayer);
if(tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success != Leader_code){
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pLeaderPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Check,
Leader_code);
pLeaderPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pLeaderPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
pOpponentPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pOpponentPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pLeaderPlayer, TRUE );
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pOpponentPlayer,FALSE );
return;
}
enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode Opponet_code =
m_cpVirtualProcessCtrl->CheckConfirmTradeBatting(pOpponentPlayer,pLeaderPlayer);
if(tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success != Opponet_code){
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pOpponentPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Check,
Opponet_code);
pOpponentPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pOpponentPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
pLeaderPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pLeaderPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pOpponentPlayer, TRUE );
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pLeaderPlayer,FALSE );
return;
}
}
pPlayer->GonryunBattlePractice.bBattingAdmitSignal = TRUE;
m_cpVirtualProcessCtrl->SetBattleType(CGonryunPractice_ProcessCtrl::PCB_BATTLE_BATTING);
m_cpVirtualProcessCtrl->SetStep(CGonryunPractice_ProcessCtrl::STEP_BATTLE_READY);
m_cpVirtualProcessCtrl->MakeTransPosition(pLeaderPlayer,pOpponentPlayer);
g_logSystem->Write("TransPort_In_Batting: LeaderName = %s Openent = %s WordIdx = %d",
pLeaderPlayer->name,
pOpponentPlayer->name,
pOpponentPlayer->worldIdx);
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
pOpponentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pOpponentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pOpponentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
int royalty = g_logic.PCBGonryunCondition.m_iroyalty;
pLeaderPlayer->curChargeSE = pLeaderPlayer->curChargeSE - royalty;
if( pLeaderPlayer->curChargeSE < 0 ) pLeaderPlayer->curChargeSE = 0;
m_cpVirtualEncoder->SendMessageNake(pLeaderPlayer);
m_cpVirtualEncoder->SendStatus(pLeaderPlayer);
m_cpVirtualEncoder->SendEffect(pLeaderPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pLeaderPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_None,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success );
pOpponentPlayer->curChargeSE= pOpponentPlayer->curChargeSE-royalty;
if( pOpponentPlayer->curChargeSE < 0 ) pOpponentPlayer->curChargeSE=0;
m_cpVirtualEncoder->SendMessageNake(pOpponentPlayer);
m_cpVirtualEncoder->SendStatus(pOpponentPlayer);
m_cpVirtualEncoder->SendEffect(pOpponentPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pOpponentPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_None,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success );
int itemIdx = -1;
item_t* item = NULL;
{
g_logSystem->Write(
"Success_recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM: Leader_Name = %s Narke = %d Win = %d Lose = %d Draw = %d",
pLeaderPlayer->name,
pLeaderPlayer->GonryunBattlePractice.iBattingSE,
pLeaderPlayer->GonryunBattlePractice.Record.iwin,
pLeaderPlayer->GonryunBattlePractice.Record.idefeat,
pLeaderPlayer->GonryunBattlePractice.Record.idraw);
for(int idx = 0; idx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; idx++ ){
if( pLeaderPlayer->GonryunBattlePractice.Inventory[idx] < 0 ) continue;
itemIdx = pLeaderPlayer->GonryunBattlePractice.Inventory[idx];
if( (0 > itemIdx) || ( itemIdx >= MAX_NUMBER_OF_OWNITEM) ) continue;
item = &pLeaderPlayer->item[itemIdx];
if( (0 > item->itemTableIdx) || ( MAX_NUMBER_OF_ITEM_TABLE <= item->itemTableIdx) ) continue;
g_logSystem->Write(
"ConfirmItem: LeaderName = %s ItemName = %s ItemNumber = %d",
pLeaderPlayer->name,
item->name,
item->durability+1);
}
}
{
g_logSystem->Write(
"Success_recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM: Openent_Name = %s Narke = %d Win = %d Lose =%d Draw =%d",
pOpponentPlayer->name,
pOpponentPlayer->GonryunBattlePractice.iBattingSE,
pOpponentPlayer->GonryunBattlePractice.Record.iwin,
pOpponentPlayer->GonryunBattlePractice.Record.idefeat,
pOpponentPlayer->GonryunBattlePractice.Record.idraw );
for(int idx = 0; idx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; idx++ ){
if( pOpponentPlayer->GonryunBattlePractice.Inventory[idx] < 0 ) continue;
itemIdx = pOpponentPlayer->GonryunBattlePractice.Inventory[idx];
if( (0 > itemIdx) || ( itemIdx >= MAX_NUMBER_OF_OWNITEM) ) continue;
item = &pOpponentPlayer->item[itemIdx];
if( (0 > item->itemTableIdx) || ( MAX_NUMBER_OF_ITEM_TABLE <= item->itemTableIdx) ) continue;
g_logSystem->Write(
"ConfirmItem: OpenentName = %s ItemName = %s ItemNumber = %d",
pOpponentPlayer->name,
item->name,
item->durability+1);
}
}
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_OK(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))) {
return;
}
int TargetIdx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer= gcpTools->GetPlayerRecordPointer(TargetIdx);
if(NULL == pTargetPlayer) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
pPlayer->GonryunBattlePractice.bBattingOkSignal = TRUE;
m_cpVirtualEncoder->SendMessage_BattingTrade_OkBatting( pPlayer, TRUE );
m_cpVirtualEncoder->SendMessage_BattingTrade_OkBatting( pTargetPlayer, FALSE );
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REQUEST(playerCharacter_t* pLeaderPlayer)
{
if((TRUE == IsBadWritePtr(pLeaderPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pLeaderPlayer,sizeof(playerCharacter_t)))) {
return;
}
if(FALSE == m_cpVirtualProcessCtrl->isBattingPlayActive()){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::busy_GonryunBattlePractice);
return;
}
if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pLeaderPlayer->GonryunBattlePractice.MemberShip){
GTH_DisconnectPlayer(pLeaderPlayer,FALSE);
return;
}
if(pLeaderPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::busy_suggest);
return;
}
char szWaitName[NAMESTRING+1]="";
strncpy( szWaitName , MSG_ReadString() , NAMESTRING );
szWaitName[NAMESTRING] = NULL;
playerCharacter_t* pWaiterPlayer = gcpTools->GetPlayerRecordPointer(szWaitName);
if(NULL == pWaiterPlayer){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pWaiterPlayer->GonryunBattlePractice.MemberShip ){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
int differlevel = abs( pLeaderPlayer->level - pWaiterPlayer->level );
if(differlevel > g_logic.PCBGonryunCondition.m_idifferLevel) {
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::differLevel,
g_logic.PCBGonryunCondition.m_idifferLevel);
return;
}
pLeaderPlayer->GonryunBattlePractice.bisWaitrespond = TRUE;
m_cpVirtualEncoder->SendMessage_BattingTrade_RequestBatting( pWaiterPlayer, pLeaderPlayer, 0 );
m_cpVirtualEncoder->SendMessage_BattingTrade_RequestBatting( pLeaderPlayer,pWaiterPlayer, 1 );
g_logSystem->Write(
"Success_recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REQUEST: LeaderName = %s WaiterName = %s",
pLeaderPlayer->name,
pWaiterPlayer->name);
}
void CGonryunPractice_Decoder::
recvRespond_NormalResult_fromOpenent(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))) {
return;
}
if(pPlayer->GonryunBattlePractice.MemberShip == playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER) {
char szWaiterName[NAMESTRING+1]="";
strncpy(szWaiterName,MSG_ReadString(),NAMESTRING); szWaiterName[NAMESTRING-1] = NULL;
playerCharacter_t* pWaiter = gcpTools->GetPlayerRecordPointer(szWaiterName);
if( NULL == pWaiter){
m_cpVirtualEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
}
else if(pWaiter->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER){
GTH_DisconnectPlayer(pPlayer,FALSE);
}
else{
m_cpVirtualEncoder->SendMessage_NormalReject_toPlayer( pWaiter );
}
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
return;
}
if(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pPlayer->GonryunBattlePractice.MemberShip ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int LeaderPCIdx = MSG_ReadLong();
char szLeaderName[NAMESTRING+1]="";
strncpy(szLeaderName,MSG_ReadString(),NAMESTRING); szLeaderName[NAMESTRING-1] = NULL;
playerCharacter_t* pLeaderPlayer = gcpTools->GetPlayerRecordPointer(LeaderPCIdx);
if(NULL == pLeaderPlayer){
m_cpVirtualEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER !=
pLeaderPlayer->GonryunBattlePractice.MemberShip ) ||
(pLeaderPlayer->idx != m_cpVirtualProcessCtrl->m_Leader.pcIdx) ||
(0 != strcmp(szLeaderName,pLeaderPlayer->name)) ||
(0 != strcmp(szLeaderName,m_cpVirtualProcessCtrl->m_Leader.Name)) ||
(pLeaderPlayer->GonryunBattlePractice.bisWaitrespond != TRUE)){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
BOOL bAccept = (BOOL)MSG_ReadByte();
if(FALSE == bAccept ){
m_cpVirtualEncoder->SendMessage_NormalReject_toPlayer( pLeaderPlayer );
pLeaderPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
return;
}
playerCharacter_t* pOpenentPlayer=pPlayer;
int royalty = g_logic.PCBGonryunCondition.m_iroyalty;
m_cpVirtualEncoder->SendWaitUserBattleEnd();
m_cpVirtualEncoder->SendWaitUserBattleEnd(pLeaderPlayer);
m_cpVirtualWaiterCtrl->DeleteAll();
m_cpVirtualProcessCtrl->SetOpenent(pOpenentPlayer);
pOpenentPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
pOpenentPlayer->curChargeSE = pOpenentPlayer->curChargeSE-royalty;
if(pOpenentPlayer->curChargeSE < 0) pOpenentPlayer->curChargeSE=0;
m_cpVirtualEncoder->SendMessageNake( pOpenentPlayer );
pLeaderPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
pLeaderPlayer->curChargeSE = pLeaderPlayer->curChargeSE-royalty;
if(pLeaderPlayer->curChargeSE < 0) pLeaderPlayer->curChargeSE =0;
m_cpVirtualEncoder->SendMessageNake(pLeaderPlayer);
m_cpVirtualProcessCtrl->SetBattleType(CGonryunPractice_ProcessCtrl::PCB_BATTLE_NORMAL);
m_cpVirtualProcessCtrl->SetStep(CGonryunPractice_ProcessCtrl::Step::STEP_BATTLE_READY);
m_cpVirtualProcessCtrl->MakeTransPosition(pLeaderPlayer,pOpenentPlayer);
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
g_logSystem->Write("TransPort_In_Generater: LeaderName = %s Openent = %s WordIdx = %d",
pLeaderPlayer->name,
pOpenentPlayer->name,
pOpenentPlayer->worldIdx);
m_cpVirtualEncoder->SendStatus(pLeaderPlayer);
m_cpVirtualEncoder->SendEffect(pLeaderPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
m_cpVirtualEncoder->SendStatus(pOpenentPlayer);
m_cpVirtualEncoder->SendEffect(pOpenentPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
ShowLogInfo("BattlePractic_WaiterCount: %d",m_cpVirtualWaiterCtrl->GetNum());
g_logSystem->Write(
"recvRespond_NormalResult_fromOpenent!! Leader_Name = %s Openent_Name = %s ",
pLeaderPlayer->name,
pOpenentPlayer->name);
return;
}
void CGonryunPractice_Decoder::recvReques_NormalBattle_FromLeader(playerCharacter_t* pLeaderPlayer)
{
if((TRUE == IsBadWritePtr(pLeaderPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pLeaderPlayer,sizeof(playerCharacter_t)))) {
return;
}
if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pLeaderPlayer->GonryunBattlePractice.MemberShip) {
GTH_DisconnectPlayer(pLeaderPlayer,FALSE);
return;
}
if(FALSE != pLeaderPlayer->GonryunBattlePractice.bisWaitrespond ){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::busy_suggest);
return;
}
struct tagGPWaitUser TempWaiter;
strncpy( TempWaiter.Name , MSG_ReadString() , NAMESTRING );
TempWaiter.Name[NAMESTRING-1] = NULL;
if(FALSE == m_cpVirtualWaiterCtrl->Find(TempWaiter,TempWaiter.Name)){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
playerCharacter_t* pWaiterPlayer = m_cpVirtualWaiterCtrl->GetWaiter(TempWaiter);
if(NULL == pWaiterPlayer ){
m_cpVirtualEncoder->SendBattleMsg(pLeaderPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
int differlevel = abs(pLeaderPlayer->level - pWaiterPlayer->level);
if(differlevel > g_logic.PCBGonryunCondition.m_idifferLevel) {
m_cpVirtualEncoder->SendBattleMsg(
pLeaderPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::differLevel,
g_logic.PCBGonryunCondition.m_idifferLevel);
return;
}
pLeaderPlayer->GonryunBattlePractice.bisWaitrespond = TRUE;
m_cpVirtualEncoder->SendReqeust_NomalBattle_toOpenent(
pLeaderPlayer->idx,
pLeaderPlayer->name,
pWaiterPlayer);
g_logSystem->Write(
"recvReques_NormalBattle_FromLeader!! Leader_Name = %s Openent_Name = %s ",
pLeaderPlayer->name,
pWaiterPlayer->name);
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ADMIT(playerCharacter_t* pWaiterPlayer)
{
if((TRUE == IsBadWritePtr(pWaiterPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pWaiterPlayer,sizeof(playerCharacter_t)))) {
return;
}
playerCharacter_t* pLeaderPlayer=NULL;
int LeaderIdx=-1;
if(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pWaiterPlayer->GonryunBattlePractice.MemberShip){
GTH_DisconnectPlayer(pWaiterPlayer,FALSE);
return;
}
LeaderIdx = MSG_ReadShort();
pLeaderPlayer= gcpTools->GetPlayerRecordPointer(LeaderIdx);
if( NULL == pLeaderPlayer ){
m_cpVirtualEncoder->SendBattleMsg(pWaiterPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pLeaderPlayer->GonryunBattlePractice.MemberShip ){
GTH_DisconnectPlayer(pWaiterPlayer,FALSE);
return;
}
if(TRUE != pLeaderPlayer->GonryunBattlePractice.bisWaitrespond){
m_cpVirtualEncoder->SendBattleMsg(pWaiterPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
m_cpVirtualEncoder->SendWaitUserBattleEnd();
m_cpVirtualEncoder->SendWaitUserBattleEnd(pLeaderPlayer);
m_cpVirtualWaiterCtrl->DeleteAll();
playerCharacter_t* pOpenentPlayer = pWaiterPlayer;
m_cpVirtualProcessCtrl->SetOpenent( pOpenentPlayer );
m_cpVirtualProcessCtrl->SetStep(CGonryunPractice_ProcessCtrl::Step::STEP_BATTING);
pLeaderPlayer->GonryunBattlePractice.iBattingSE = 0;
pLeaderPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
pLeaderPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
m_cpVirtualProcessCtrl->InitTradeBatting(pLeaderPlayer );
m_cpVirtualEncoder->SendMessage_BattingTrade_AdmitBatting( pLeaderPlayer);
pLeaderPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
pOpenentPlayer->GonryunBattlePractice.iBattingSE = 0;
pOpenentPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
pOpenentPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
m_cpVirtualProcessCtrl->InitTradeBatting( pOpenentPlayer );
m_cpVirtualEncoder->SendMessage_BattingTrade_AdmitBatting( pOpenentPlayer);
pOpenentPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
g_logSystem->Write(
"recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ADMIT!! Leader_Name = %s Openent_Name = %s ",
pLeaderPlayer->name,
pOpenentPlayer->name);
}
CGonryunPractice_Decoder::CGonryunPractice_Decoder()
{
m_bOK=FALSE;
m_cpVirtualPracticeBattle = NULL;
m_cpVirtualEncoder = NULL;
m_cpVirtualProcessCtrl = NULL;
m_cpVirtualWaiterCtrl =NULL;
m_bOK=TRUE;
}
CGonryunPractice_Decoder::~CGonryunPractice_Decoder()
{
}
void CGonryunPractice_Decoder::recvPacket(void)
{
byte command = MSG_ReadByte();
switch ( command ){
case BATTLE_PRACTICE_REQUEST_BATTELGENERATE :
recvReques_NormalBattle_FromLeader(g_curPC);
break;
case BATTLE_PRACTICE_GENERATE_RESULT :
recvRespond_NormalResult_fromOpenent(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_RESULT :
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ADMIT(g_curPC);
break;
case BATTEL_PRACTICE_GET_CANCEL:
recvRespond_CancelBattle_fromOpenent(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_REQUEST:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REQUEST(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_REJECT:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REJECT(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_EXIT :
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_EXIT(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_OK:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_OK(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_CANCEL:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CANCEL(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_CONFIRM:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_ITEM:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ITEM(g_curPC);
break;
case BATTLE_PRACTICE_BATTINGTRADE_SE:
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_SE(g_curPC);
break;
case BATTLE_PRACTICE_BAN:
recPaketProcces_BATTLE_PRACTICE_BAN();
break;
case BATTLE_PRACTICE_START:
recPaketProcces_BATTLE_PRACTICE_START(g_curPC);
break;
case BATTLE_PRACTICE_POSITION:
recPatketProcces_BATTLE_PRACTICE_POSITION(g_curPC);
break;
case BATTLE_PRACTICE_BAN_BATTING:
recPatketProcces_BanBattingBattle();
break;
case BATTLE_PRACTICE_CANCEL_BATTING:
recPatketProcces_CancelBattingBattle();
break;
case BATTLE_PRACTICE_FAILADDITEM:
recPatketProcces_BATTLE_PRACTICE_FAILADDITEM(g_curPC);
break;
}
}
void CGonryunPractice_Decoder::recPatketProcces_BATTLE_PRACTICE_FAILADDITEM(playerCharacter_t* pPlayer)
{
GTH_DisconnectPlayer(pPlayer,FALSE);
}
BOOL CGonryunPractice_Decoder::isOK(void)
{
return m_bOK;
}
void CGonryunPractice_Decoder::Set(CGonryunPracticeBattle* pPracticeBattle)
{
m_cpVirtualPracticeBattle = pPracticeBattle;
m_cpVirtualProcessCtrl = pPracticeBattle->GetProcessCtrl();
m_cpVirtualWaiterCtrl = pPracticeBattle->GetWaiterCtrl();
m_cpVirtualEncoder = pPracticeBattle->GetEncoder();
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_ITEM(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))){
return;
}
item_t* pMouseItem = NULL;
item_t* pPlayerArrayItem = NULL;
int pos = -1;
int playerArrayItemIdx_forAddItem = -1;
int GBPInventoryIdx = 0;
BOOL bisExchange = TRUE;
playerCharacter_t* pTargetPlayer = NULL;
int TargetIdx = MSG_ReadShort();
pTargetPlayer = gcpTools->GetPlayerRecordPointer(TargetIdx);
if(NULL == pTargetPlayer) goto unknown_error_player_disconnect;
pos = MSG_ReadByte();
if( ( 0 > pos ) || ( playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE <= pos ) ) goto unknown_error_player_disconnect;
switch(pPlayer->GonryunBattlePractice.MemberShip){
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER:
if(pTargetPlayer->GonryunBattlePractice.MemberShip !=
playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT)
goto unknown_error_player_disconnect;
break;
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT:
if(pTargetPlayer->GonryunBattlePractice.MemberShip !=
playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER)
goto unknown_error_player_disconnect;
break;
default:
goto unknown_error_player_disconnect;
}
if( ( pPlayer->mouseInventory >= 0 ) &&
( pPlayer->GonryunBattlePractice.Inventory[pos] >= 0 ) ) {
pMouseItem = gcpTools->GetMyItem(pPlayer,pPlayer->mouseInventory);
if(NULL == pMouseItem) goto unknown_error_player_disconnect;
if( TRUE == gcpTools->IsStackItem(pMouseItem) ) {
for( GBPInventoryIdx = 0; GBPInventoryIdx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPInventoryIdx++){
if( 0 > pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx] )continue;
pPlayerArrayItem = gcpTools->GetMyItem(pPlayer,pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx]);
if( NULL == pPlayerArrayItem ) goto unknown_error_player_disconnect;
if( pPlayerArrayItem->itemTableIdx != pMouseItem->itemTableIdx ) continue;
bisExchange = FALSE;
break;
}
}
if( TRUE == bisExchange ){
int tempItemArrayIdx = pPlayer->mouseInventory;
pPlayer->mouseInventory = pPlayer->GonryunBattlePractice.Inventory[pos];
pPlayer->GonryunBattlePractice.Inventory[pos] = tempItemArrayIdx;
pPlayerArrayItem = gcpTools->GetMyItem(pPlayer,tempItemArrayIdx);
if(NULL == pPlayerArrayItem) goto unknown_error_player_disconnect;
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pTargetPlayer,
FALSE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_EXCHANGE,
pos,
pPlayerArrayItem);
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pPlayer,
TRUE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_EXCHANGE,
pos,
pPlayerArrayItem);
return;
}
}
if( pPlayer->mouseInventory >= 0 ) {
pMouseItem = gcpTools->GetMyItem(pPlayer,pPlayer->mouseInventory);
if(NULL == pMouseItem) goto unknown_error_player_disconnect;
if( TRUE == gcpTools->IsStackItem(pMouseItem) ) {
for( GBPInventoryIdx = 0; GBPInventoryIdx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPInventoryIdx++){
if( 0 > pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx] )continue;
pPlayerArrayItem = gcpTools->GetMyItem(pPlayer,pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx]);
if( NULL == pPlayerArrayItem ) goto unknown_error_player_disconnect;
if( pPlayerArrayItem->itemTableIdx != pMouseItem->itemTableIdx ) continue;
pPlayerArrayItem->durability += pMouseItem->durability+1;
if(pPlayerArrayItem->durability >= MAX_COUNT_STACK_ITEM ) pPlayerArrayItem->durability = MAX_COUNT_STACK_ITEM - 1;
g_DBGameServer->SaveItem( pPlayer, pPlayerArrayItem,pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx]);
GTH_DeleteMyItem( pPlayer, pMouseItem );
g_DBGameServer->RemoveItem( pPlayer, pPlayer->mouseInventory );
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pTargetPlayer,
FALSE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_ADD,
GBPInventoryIdx,
pPlayerArrayItem);
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pPlayer,
TRUE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_STACK_ADD,
GBPInventoryIdx,
pPlayerArrayItem,
pPlayer->mouseInventory);
pPlayer->mouseInventory=-1;
return;
}
}
for( GBPInventoryIdx = 0; GBPInventoryIdx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPInventoryIdx++){
if( 0 <= pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx] )continue;
pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx] = pPlayer->mouseInventory;
pPlayer->mouseInventory=-1;
pPlayerArrayItem = gcpTools->GetMyItem(pPlayer,pPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx]);
if( NULL == pPlayerArrayItem ) goto unknown_error_player_disconnect;
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pTargetPlayer,
FALSE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_ADD,
GBPInventoryIdx,
pPlayerArrayItem);
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pPlayer,
TRUE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_ADD,
GBPInventoryIdx,
pPlayerArrayItem);
return;
}
goto unknown_error_player_disconnect;
}
if( pPlayer->mouseInventory < 0 &&
pPlayer->GonryunBattlePractice.Inventory[pos] >= 0 ) {
pPlayerArrayItem = gcpTools->GetMyItem(pPlayer,pPlayer->GonryunBattlePractice.Inventory[pos]);
if(NULL == pPlayerArrayItem) goto unknown_error_player_disconnect;
pPlayer->mouseInventory = pPlayer->GonryunBattlePractice.Inventory[pos];
pPlayer->GonryunBattlePractice.Inventory[pos]=-1;
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(
pTargetPlayer,
FALSE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_DELETE,
pos,
pPlayerArrayItem);
m_cpVirtualEncoder->SendMessage_BattingTrade_ItemBatting(pPlayer,
TRUE,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::TYPE_DELETE,
pos,
pPlayerArrayItem);
return;
}
unknown_error_player_disconnect:
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
void CGonryunPractice_Decoder::recvRespond_CancelBattle_fromOpenent(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))) {
return;
}
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE
== pPlayer->GonryunBattlePractice.MemberShip)) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
m_cpVirtualProcessCtrl->IrregularQuitBattle(pPlayer);
}
void CGonryunPractice_Decoder::recPatketProcces_BATTLE_PRACTICE_POSITION(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))){
return;
}
vec3_t position;
position[0]=MSG_ReadFloat();
position[1]=MSG_ReadFloat();
position[2]=MSG_ReadFloat();
m_cpVirtualProcessCtrl->MakeTransPort(pPlayer,position);
}
void CGonryunPractice_Decoder::recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_EXIT(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))) {
return;
}
if((pPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER) &&
(pPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT)){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int TargetIdx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer( TargetIdx );
if( NULL == pTargetPlayer ) {
m_cpVirtualEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if((pTargetPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER) &&
(pTargetPlayer->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT)){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
m_cpVirtualProcessCtrl->IrregularQuitBattle(pPlayer);
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REJECT(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))) {
return;
}
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pPlayer->GonryunBattlePractice.MemberShip ) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pPlayer->GonryunBattlePractice.MemberShip )){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int TargetIdx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(TargetIdx);
if( NULL == pTargetPlayer ) {
m_cpVirtualEncoder->SendBattleMsg(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pTargetPlayer->GonryunBattlePractice.MemberShip ) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pTargetPlayer->GonryunBattlePractice.MemberShip )) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER
== pPlayer->GonryunBattlePractice.MemberShip ){
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
m_cpVirtualEncoder->SendMessage_BattingTrade_RejectBatting( pPlayer, TRUE );
m_cpVirtualEncoder->SendMessage_BattingTrade_RejectBatting( pTargetPlayer, FALSE );
}
else if( playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER
== pTargetPlayer->GonryunBattlePractice.MemberShip ) {
pTargetPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
m_cpVirtualEncoder->SendMessage_BattingTrade_RejectBatting( pPlayer, FALSE );
m_cpVirtualEncoder->SendMessage_BattingTrade_RejectBatting( pTargetPlayer, TRUE );
}
g_logSystem->Write(
"Success_recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_REQUEST: RejectName = %s beRejectName = %s",
pPlayer->name,
pTargetPlayer->name);
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_SE(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))) {
return;
}
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pPlayer->GonryunBattlePractice.MemberShip) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT != pPlayer->GonryunBattlePractice.MemberShip) ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int TargetIdx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer = gcpTools->GetPlayerRecordPointer(TargetIdx);
if(NULL == pTargetPlayer){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pTargetPlayer->GonryunBattlePractice.MemberShip) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT != pTargetPlayer->GonryunBattlePractice.MemberShip) ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int narke = MSG_ReadLong();
if( narke > (pPlayer->curChargeSE - g_logic.PCBGonryunCondition.m_iroyalty)){
m_cpVirtualEncoder->SendMessage_BattingTrade_SEBatting(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_NotEnough_Nake,
TRUE,
narke );
return;
}
if( g_logic.PCBGonryunCondition.m_ibattingRoyalty < narke){
m_cpVirtualEncoder->SendMessage_BattingTrade_SEBatting(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_Over_BattingNake,
TRUE,
narke );
return;
}
pPlayer->GonryunBattlePractice.iBattingSE = narke;
m_cpVirtualEncoder->SendMessage_BattingTrade_SEBatting(
pPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success,
TRUE,
narke );
m_cpVirtualEncoder->SendMessage_BattingTrade_SEBatting(
pTargetPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success,
FALSE,
narke );
}
void CGonryunPractice_Decoder::recPaketProcces_BATTLE_PRACTICE_BAN()
{
m_cpVirtualProcessCtrl->SetActive(FALSE);
}
void CGonryunPractice_Decoder::recPaketProcces_BATTLE_PRACTICE_START(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t))) {
return;
}
int minLevel=MSG_ReadLong();
if( ( 0 >= minLevel ) || ( 99 < minLevel ) ){
GTH_DisconnectPlayer( pPlayer,FALSE );
return;
}
int maxLevel=MSG_ReadLong();
if( ( 0 >= maxLevel ) || ( 99 < maxLevel ) ) {
GTH_DisconnectPlayer( pPlayer,FALSE );
return;
}
if( minLevel >= maxLevel ) return;
m_cpVirtualProcessCtrl->SetActive(TRUE);
switch (pPlayer->worldIdx)
{
case CGonryunPractice_ProcessCtrl::ARAYANWORLDMAP:
{
g_logic.PCBGonryunCondition.m_iminiLevel = minLevel;
g_logic.PCBGonryunCondition.m_imaxLevel = maxLevel;
}
break;
case CGonryunPractice_ProcessCtrl::SYENWORDMAP:
{
g_logic.PCBGonryunCondition.m_isyenminilevel = minLevel;
g_logic.PCBGonryunCondition.m_isyenmaxlevel = maxLevel;
}
break;
}
}
void CGonryunPractice_Decoder::
recPaketProcces_BATTLE_PRACTICE_BATTINGTRADE_CANCEL(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))) {
return;
}
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pPlayer->GonryunBattlePractice.MemberShip) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT != pPlayer->GonryunBattlePractice.MemberShip) ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int Tagetidx = MSG_ReadShort();
playerCharacter_t* pTargetPlayer= gcpTools->GetPlayerRecordPointer(Tagetidx);
if(NULL == pTargetPlayer){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER != pTargetPlayer->GonryunBattlePractice.MemberShip) &&
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT != pTargetPlayer->GonryunBattlePractice.MemberShip) ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
pPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
pTargetPlayer->GonryunBattlePractice.bBattingOkSignal = FALSE;
pTargetPlayer->GonryunBattlePractice.bBattingAdmitSignal = FALSE;
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pPlayer, TRUE );
m_cpVirtualEncoder->SendMessage_BattingTrade_CancelBatting( pTargetPlayer,FALSE );
}
void CGonryunPractice_Decoder::
recPatketProcces_BanBattingBattle(void)
{
m_cpVirtualProcessCtrl->SetBattingBattle(FALSE);
}
void CGonryunPractice_Decoder::
recPatketProcces_CancelBattingBattle(void)
{
m_cpVirtualProcessCtrl->SetBattingBattle(TRUE);
}
| C++ |
#include "..\global.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPractice_RewordCtrl.h"
#include "CGonryunPractice_Encoder.h"
#include "..\Tools\CTools.h"
#include "../Tools/CTempPlayerInventoryX.h"
extern CTools* gcpTools;
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
#include "..\GolryunBattle\CGolryunBattle.h"
extern CGolryunBattle* gcpGolryunBattle;
void CGonryunPractice_ProcessCtrl::
GiveBattingWinner(playerCharacter_t* pwinor,playerCharacter_t* pdefeator)
{
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode Code =
CheckConfirmTradeBatting( pwinor,pdefeator);
if(Code == tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success){
ConfirmTradeBattingWinerGive(pwinor,pdefeator);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pwinor,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Win,
Code);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(pdefeator,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Defeate,
Code);
InitTradeBatting( pwinor );
InitTradeBatting( pdefeator);
g_logSystem->Write("Success GiveBatting Name = %s", pwinor->name);
} else{
BattingRestore(pwinor);
BattingRestore(pdefeator);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pwinor,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Fail, Code);
m_cpVirtualEncoder->SendMessage_BattingTrade_ConfirmBatting(
pdefeator,
tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::State_Fail,
Code);
g_logSystem->Write("NotGiveBatting Name = %s Code = %d", pwinor->name,Code);
}
GTH_PC_Calculate( pwinor, PCINFO_BASIC );
GTH_PC_Calculate(pdefeator, PCINFO_BASIC );
}
CGonryunPractice_ProcessCtrl::CGonryunPractice_ProcessCtrl()
{
m_bOK=FALSE;
m_cpVirtualWaiterCtrl = NULL;
m_cpVirtualRewordCtrl = NULL;
m_cpVirtualEncoder = NULL;
m_Leader.pcIdx=-1;
m_Openent.pcIdx=-1;
m_Winner.pcIdx=-1;
m_Loser.pcIdx=-1;
m_BattleType = PCB_BATTLE_NONE;
m_Step = STEP_NONE;
m_dwStatusStartTime = 0;
SetActive(FALSE);
m_bIsBattleBatting = TRUE;
m_bOK=TRUE;
}
BOOL CGonryunPractice_ProcessCtrl::isOK(void)
{
return m_bOK;
}
void CGonryunPractice_ProcessCtrl::Init(void)
{
m_Leader.pcIdx = -1;
m_Openent.pcIdx = -1;
m_Winner.pcIdx = -1;
m_Loser.pcIdx = -1;
m_BattleType = PCB_BATTLE_NONE;
m_cpVirtualWaiterCtrl->DeleteAll();
SetStep(STEP_NONE);
m_dwStatusStartTime = 0;
}
void CGonryunPractice_ProcessCtrl::Set(CGonryunPracticeBattle* pPracticeBattle)
{
m_cpVirtualWaiterCtrl = pPracticeBattle->GetWaiterCtrl();
m_cpVirtualRewordCtrl = pPracticeBattle->GetRewordCtrl();
m_cpVirtualEncoder = pPracticeBattle->GetEncoder();
}
void CGonryunPractice_ProcessCtrl::
ConfirmTradeBattingWinerGive(playerCharacter_t* pwinor , playerCharacter_t* pdefeator)
{
pwinor->curChargeSE+=pdefeator->GonryunBattlePractice.iBattingSE;
if( pwinor->curChargeSE > MAX_OWN_NAK ) pwinor->curChargeSE = MAX_OWN_NAK;
m_cpVirtualEncoder->SendMessageNake(pwinor);
g_logSystem->Write(
"ConfirmTradeBattingWinerGive WinorName = %s ObtainNarke = %d ",
pwinor->name,
pdefeator->GonryunBattlePractice.iBattingSE);
pdefeator->curChargeSE-=pdefeator->GonryunBattlePractice.iBattingSE;
if( pdefeator->curChargeSE < 0 ) pdefeator->curChargeSE = 0;
m_cpVirtualEncoder->SendMessageNake(pdefeator);
g_logSystem->Write(
"ConfirmTradeBattingWinerGive LoserName = %s LoseNarke = %d ",
pdefeator->name,
pdefeator->GonryunBattlePractice.iBattingSE);
ConfirmTradeBattingWinerGive_Item(pwinor,pdefeator);
}
void CGonryunPractice_ProcessCtrl::
ConfirmTradeBattingWinerGive_Item(playerCharacter_t* pwinor , playerCharacter_t* pdefeator)
{
UndoBattingTradeBatting( pwinor);
m_cpVirtualEncoder->SendMessage_BattingTrade_ExitBatting( pwinor);
int playerItemArrayIdx = -1;
item_t* item = NULL;
for(int idx = 0; idx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; idx++ ){
if( pdefeator->GonryunBattlePractice.Inventory[idx] < 0 ) continue;
playerItemArrayIdx = pdefeator->GonryunBattlePractice.Inventory[idx];
if( (0 > playerItemArrayIdx) || ( playerItemArrayIdx >= MAX_NUMBER_OF_OWNITEM) ) continue;
item = &pdefeator->item[playerItemArrayIdx];
if( (0 > item->itemTableIdx) || ( MAX_NUMBER_OF_ITEM_TABLE <= item->itemTableIdx) ) continue;
if(TRUE == gcpTools->AddItemBatting(pwinor,*item)){
g_logSystem->Write(
"Success_AddBattingItem: UserName = %s ItemName = %s ItemNumber = %d",
pwinor->name,
item->name,
item->durability+1);
GTH_DeleteMyItem( pdefeator, item );
g_DBGameServer->RemoveItem(pdefeator, playerItemArrayIdx);
} else{
g_logSystem->Write(
"Fail_AddBattingItem: UserName = %s ItemName = %s ItemNumber = %d",
pwinor->name,
item->name,
item->durability+1);
}
}
}
void CGonryunPractice_ProcessCtrl::InitTradeBatting( playerCharacter_t* pPlayer )
{
pPlayer->GonryunBattlePractice.iBattingSE = 0;
for(int idx = 0; idx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; idx ++ ){
pPlayer->GonryunBattlePractice.Inventory[idx] = -1;
}
}
int CGonryunPractice_ProcessCtrl::
UndoBattingTradeBatting(playerCharacter_t* pPlayer)
{
item_t *item = NULL, *upItem = NULL;
int playerItemArrayIdx=-1;
for( int idx = 0; idx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; idx ++ )
{
playerItemArrayIdx = pPlayer->GonryunBattlePractice.Inventory[idx];
if( playerItemArrayIdx < 0 ) continue;
if( playerItemArrayIdx >= MAX_NUMBER_OF_OWNITEM) continue;
item = &pPlayer->item[playerItemArrayIdx];
if( (0 > item->itemTableIdx) || ( item->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) ) continue;
int stackItemIdx = GTH_StackMyItem( pPlayer, item );
if( stackItemIdx >= 0 ){
upItem = &pPlayer->item[stackItemIdx];
upItem->durability += item->durability + 1;
if(upItem->durability >= MAX_COUNT_STACK_ITEM ) upItem->durability = MAX_COUNT_STACK_ITEM - 1;
pPlayer->GonryunBattlePractice.Inventory[idx]=-1;
GTH_DeleteMyItem( pPlayer, item );
g_DBGameServer->RemoveItem( pPlayer, playerItemArrayIdx );
g_DBGameServer->SaveItem( pPlayer, upItem, stackItemIdx );
} else {
int inventoryPos = GTH_FindEmptyInventoryPos( pPlayer );
if( inventoryPos >= 0 ) {
pPlayer->inventory[inventoryPos] = playerItemArrayIdx;
pPlayer->GonryunBattlePractice.Inventory[idx]=-1;
}
}
}
CheckItemInformation( pPlayer, LOG_CLASS_ITEM_MISSMATCH_TYPE_BATTINGTRADE );
return 1;
}
void CGonryunPractice_ProcessCtrl::
GetWinnerPortalPos(playerCharacter_t* pPlayer)
{
vec3_t pos;
if( pPlayer->worldIdx == ARAYANWORLDMAP )
{
gonryunFieldPos_t taraynwinnerPos = g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos;
pos[0] = taraynwinnerPos.m_fbattlein_x;
pos[1] = taraynwinnerPos.m_fbattlein_y;
pos[2] = taraynwinnerPos.m_fbattlein_z;
pPlayer->angles[1] = taraynwinnerPos.m_fbattlein_yaw;
MakeTransPort( pPlayer, pos);
} else if( pPlayer->worldIdx == SYENWORDMAP ){
gonryunFieldPos_t tsyenwinnerPos = g_logic.PCBGonryunCondition.m_tsyenOutPos;
pos[0] = tsyenwinnerPos.m_fbattlein_x;
pos[1] = tsyenwinnerPos.m_fbattlein_y;
pos[2] = tsyenwinnerPos.m_fbattlein_z;
MakeTransPort( pPlayer, pos);
g_logSystem->Write("GetWinnerPortalPos Spawn pPlayer name=%s pos.x=%f,pos.y=%f,pos.z=%f",
pPlayer->name,
pPlayer->position[0],
pPlayer->position[1],
pPlayer->position[2]);
}
}
void CGonryunPractice_ProcessCtrl::
IrregularQuitBattle(playerCharacter_t* pOutPlayer)
{
if(NULL == pOutPlayer){
g_logSystem->Write("NULL == pOutPlayer void CGonryunPractice_ProcessCtrl::IrregularQuitBattle(playerCharacter_t* pOutPlayer)");
return;
}
switch(m_Step){
case STEP_NONE:
break;
case STEP_SUGGUEST:
IrregularQuitBattle_Suggent(pOutPlayer);
break;
case STEP_BATTING:
IrregularQuitBattle_Batting(pOutPlayer);
break;
case STEP_BATTLE_READY:
case STEP_FIGHTING:
IrregularQuitBattle_Fighting(pOutPlayer);
break;
case STEP_BATTLE_END:
IrregularQuitBattle_End(pOutPlayer);
break;
}
}
void CGonryunPractice_ProcessCtrl::
IrregularQuitBattle_Suggent(playerCharacter_t* pOutPlayer)
{
switch(pOutPlayer->GonryunBattlePractice.MemberShip){
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE:
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT:
return;
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER:
m_cpVirtualEncoder->SendWaitUserBattleEnd();
m_cpVirtualEncoder->SendWaitUserBattleEnd(pOutPlayer);
Init();
pOutPlayer->busyState = BUSY_STATE_NONE;
pOutPlayer->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pOutPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
return;
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER:
m_cpVirtualEncoder->SendDeleteUser(pOutPlayer);
m_cpVirtualWaiterCtrl->Delete(pOutPlayer);
pOutPlayer->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pOutPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
pOutPlayer->busyState = BUSY_STATE_NONE;
ShowLogInfo("DELETE USERNAME = %s Count = %d", pOutPlayer->name,m_cpVirtualWaiterCtrl->GetNum()+1);
return;
default :
g_logSystem->Write("IrregularQuitBattle_Suggent: UserName = %s ", pOutPlayer->name);
return;
}
}
void CGonryunPractice_ProcessCtrl::
IrregularQuitBattle_Batting(playerCharacter_t* pOutPlayer)
{
switch(pOutPlayer->GonryunBattlePractice.MemberShip) {
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE:
return;
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER:
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT:
break;
}
playerCharacter_t* pLeaderPlayer = NULL;
pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if(NULL != pLeaderPlayer) {
BattingRestore(pLeaderPlayer);
InitNoticePC(pLeaderPlayer);
}
playerCharacter_t* pOpenentPlayer = NULL;
pOpenentPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
if( NULL != pOpenentPlayer) {
BattingRestore(pOpenentPlayer);
InitNoticePC(pOpenentPlayer);
}
Init();
}
void CGonryunPractice_ProcessCtrl::
IrregularQuitBattle_Fighting(playerCharacter_t* pOutPlayer)
{
if((pOutPlayer->GonryunBattlePractice.MemberShip == playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE)||
(pOutPlayer->GonryunBattlePractice.MemberShip == playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER))
return;
CheckGameEnd(pOutPlayer,BATTLE_END_RESULT_BORN);
}
void CGonryunPractice_ProcessCtrl::
IrregularQuitBattle_End(playerCharacter_t* pOutPlayer)
{
if(pOutPlayer->GonryunBattlePractice.MemberShip
== playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE) return;
CheckAndMove();
Init();
}
void CGonryunPractice_ProcessCtrl::SetStep(const enum Step& step)
{
m_Step = step;
m_dwStatusStartTime = g_globalTime ;
switch ( m_Step ){
case STEP_NONE:
ShowLogInfo("PCB_STATUS : STEP_NONE, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
case STEP_SUGGUEST:
ShowLogInfo("PCB_STATUS : STEP_SUGGUEST, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
case STEP_BATTING:
ShowLogInfo("PCB_STATUS : STEP_BATTING, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
case STEP_BATTLE_READY:
ShowLogInfo("PCB_STATUS : STEP_BATTLE_READY, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
case STEP_FIGHTING:
ShowLogInfo("PCB_STATUS : STEP_FIGHTING, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
case STEP_BATTLE_END :
ShowLogInfo("PCB_STATUS : STEP_BATTLE_END, COUNT = %d " , m_cpVirtualWaiterCtrl->GetNum());
break;
}
}
BOOL CGonryunPractice_ProcessCtrl::
SuggestPlayer(playerCharacter_t* pSuggestPlayer)
{
switch(m_Step){
case STEP_NONE:
SetLeader( pSuggestPlayer );
SetStep(STEP_SUGGUEST);
ShowLogInfo( " USERCOUNT: %d " , m_cpVirtualWaiterCtrl->GetNum());
m_cpVirtualEncoder->SendWaitUserList(pSuggestPlayer,pSuggestPlayer);
ShowLogInfo( " USERCOUNT: %d " ,m_cpVirtualWaiterCtrl->GetNum()+1 );
return TRUE;
case STEP_SUGGUEST:
{
playerCharacter_t* pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if( NULL == pLeaderPlayer){
Init();
return FALSE;
}
if(pSuggestPlayer == pLeaderPlayer) return FALSE;
struct tagGPWaitUser WaitUser;
if(TRUE == m_cpVirtualWaiterCtrl->Find(WaitUser,pSuggestPlayer->name)){
return FALSE;
}
memset(&WaitUser,0x00,sizeof(struct tagGPWaitUser));
WaitUser.pcIdx = pSuggestPlayer->idx;
strncpy(WaitUser.Name,pSuggestPlayer->name,NAMESTRING);
WaitUser.Name[NAMESTRING] = NULL;
strncpy(WaitUser.ID,pSuggestPlayer->userID,IDSTRING);
WaitUser.ID[IDSTRING] = NULL;
m_cpVirtualWaiterCtrl->Insert(WaitUser);
pSuggestPlayer->GonryunBattlePractice.MemberShip =
playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER;
m_cpVirtualEncoder->SendWaitUserList(pLeaderPlayer,pSuggestPlayer);
m_cpVirtualEncoder->SendMyInfoToUser(pLeaderPlayer,pSuggestPlayer);
int waitercount = m_cpVirtualWaiterCtrl->GetNum()+1;
ShowLogInfo("USERCOUNT: %d",waitercount);
}
return TRUE;
default:
return FALSE;
}
return FALSE;
}
void CGonryunPractice_ProcessCtrl::Update_Sugguest(const int time)
{
if ( time > g_logic.PCBGonryunCondition.PCBStatusTime[STEP_SUGGUEST] )
{
playerCharacter_t* pLeader = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if(NULL != pLeader){
pLeader->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pLeader->GonryunBattlePractice.bisWaitrespond = FALSE;
m_cpVirtualEncoder->SendWaitUserBattleEnd(pLeader);
}
m_cpVirtualEncoder->SendWaitUserBattleEnd();
Init();
return;
}
}
void CGonryunPractice_ProcessCtrl::Update_Batting(const int time)
{
if ( time > g_logic.PCBGonryunCondition.PCBStatusTime[STEP_BATTING] )
{
playerCharacter_t* pLeader = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if(NULL != pLeader){
BattingRestore(pLeader);
InitNoticePC(pLeader);
}
playerCharacter_t* pOpenent = m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
if(NULL != pOpenent){
BattingRestore(pOpenent);
InitNoticePC(pOpenent);
}
Init();
}
}
void CGonryunPractice_ProcessCtrl::Update_Battle_Ready(const int time)
{
if ( time > g_logic.PCBGonryunCondition.PCBStatusTime[STEP_BATTLE_READY])
{
SetStep(STEP_FIGHTING);
DWORD remainTime = g_logic.PCBGonryunCondition.PCBStatusTime[STEP_FIGHTING];
playerCharacter_t* pLeader = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if( NULL != pLeader ){
m_cpVirtualEncoder->SendStatus(pLeader);
m_cpVirtualEncoder->SendGonryunBattleInfo(pLeader,remainTime);
pLeader->pvpMode = TRUE;
}
playerCharacter_t* pOpenent= m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
if(NULL != pOpenent){
m_cpVirtualEncoder->SendStatus(pOpenent);
m_cpVirtualEncoder->SendGonryunBattleInfo(pOpenent,remainTime);
pOpenent->pvpMode = TRUE;
}
}
}
void CGonryunPractice_ProcessCtrl::Update_Fighting(const int time)
{
if ( time > g_logic.PCBGonryunCondition.PCBStatusTime[STEP_FIGHTING])
{
CheckGameEnd(NULL, BATTLE_END_DRAW);
return;
}
}
void CGonryunPractice_ProcessCtrl::Update_Battle_End(const int time)
{
if ( time > g_logic.PCBGonryunCondition.PCBStatusTime[STEP_BATTLE_END])
{
CheckAndMove();
Init();
}
}
void CGonryunPractice_ProcessCtrl::Update(void)
{
if ( m_Step == STEP_NONE )
return;
DWORD remainTime = g_globalTime - m_dwStatusStartTime;
switch ( m_Step ){
case STEP_NONE:
break;
case STEP_SUGGUEST:
Update_Sugguest(remainTime);
break;
case STEP_BATTING:
Update_Batting(remainTime);
break;
case STEP_BATTLE_READY:
Update_Battle_Ready(remainTime);
break;
case STEP_FIGHTING:
Update_Fighting(remainTime);
break;
case STEP_BATTLE_END:
Update_Battle_End(remainTime);
break;
}
}
void CGonryunPractice_ProcessCtrl::MakeTransPort(playerCharacter_t* pPlayer,const vec3_t leaderposition)
{
pPlayer->position[0] = leaderposition[0];
pPlayer->position[1] = leaderposition[1];
pPlayer->position[2] = leaderposition[2];
pPlayer->zoneIdx = GTH_Zone_UpdateCurrentZone(
ENTITY_PC,
pPlayer->idx,
pPlayer->worldIdx,
pPlayer->zoneIdx,
pPlayer->position);
GTH_SendPCEventMessage_Respawn( pPlayer );
GTH_SendMessage_SyncItemObject( pPlayer );
g_logSystem->Write("GoryunBattlePractice Spawn pPlayer name=%s pos.x=%f,pos.y=%f,pos.z=%f",
pPlayer->name,
pPlayer->position[0],
pPlayer->position[1],
pPlayer->position[2]);
}
void CGonryunPractice_ProcessCtrl::GeLoserPortalPos(playerCharacter_t* pLoserPlayer)
{
vec3_t pos;
if( pLoserPlayer->worldIdx == ARAYANWORLDMAP )
{
gonryunFieldPos_t tdefeaterPos = g_logic.PCBGonryunCondition.m_tarayandefeatorOutPos;
pos[0] = tdefeaterPos.m_fbattlein_x;
pos[1] = tdefeaterPos.m_fbattlein_y;
pos[2] = tdefeaterPos.m_fbattlein_z;
pLoserPlayer->angles[1] = tdefeaterPos.m_fbattlein_yaw;
MakeTransPort( pLoserPlayer, pos);
} else if( pLoserPlayer->worldIdx == SYENWORDMAP ){
gonryunFieldPos_t tsyenwinnerPos = g_logic.PCBGonryunCondition.m_tsyenOutPos;
pos[0] = tsyenwinnerPos.m_fbattlein_x;
pos[1] = tsyenwinnerPos.m_fbattlein_y;
pos[2] = tsyenwinnerPos.m_fbattlein_z;
MakeTransPort( pLoserPlayer, pos);
g_logSystem->Write("GeLoserPortalPos Spawn pPlayer name=%s pos.x=%f,pos.y=%f,pos.z=%f",
pLoserPlayer->name,
pLoserPlayer->position[0],
pLoserPlayer->position[1],
pLoserPlayer->position[2]);
}
}
void CGonryunPractice_ProcessCtrl::CheckAndMove(void)
{
playerCharacter_t* pWinnerPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Winner);
playerCharacter_t* pLoserPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Loser);
playerCharacter_t* pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
playerCharacter_t* pOpenentPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
SetStep(STEP_NONE);
if( ( NULL == pWinnerPlayer ) && ( NULL == pLoserPlayer ) ){
if( NULL != pLeaderPlayer ){
GetWinnerPortalPos(pLeaderPlayer);
InitNoticePC(pLeaderPlayer);
m_cpVirtualEncoder->SendStatus(pLeaderPlayer);
m_cpVirtualEncoder->SendBattleMsg(
pLeaderPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_Lest_UseCount,
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
}
if( NULL != pOpenentPlayer ){
GetWinnerPortalPos(pOpenentPlayer);
InitNoticePC(pOpenentPlayer);
m_cpVirtualEncoder->SendStatus(pOpenentPlayer);
m_cpVirtualEncoder->SendBattleMsg(
pOpenentPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_Lest_UseCount,
pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
}
return;
}
if(NULL != pWinnerPlayer){
GetWinnerPortalPos(pWinnerPlayer);
InitNoticePC(pWinnerPlayer);
m_cpVirtualEncoder->SendStatus(pWinnerPlayer);
m_cpVirtualEncoder->SendBattleMsg(
pWinnerPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_Lest_UseCount,
pWinnerPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
}
if(NULL != pLoserPlayer){
GeLoserPortalPos(pLoserPlayer);
pLoserPlayer->alive = TRUE;
pLoserPlayer->event = GTH_EV_CHAR_IDLE;
InitNoticePC(pLoserPlayer);
m_cpVirtualEncoder->SendStatus(pLoserPlayer);
m_cpVirtualEncoder->SendBattleMsg(
pLoserPlayer,
tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::gonryun_Lest_UseCount,
pLoserPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
}
}
void CGonryunPractice_ProcessCtrl::CheckOverFlowUseCount(playerCharacter_t* pUserPlayer)
{
int* pPlayer = &(pUserPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount);
(*pPlayer)--;
if(*pPlayer < MAX_OVERFLOW)
*pPlayer = 0;
}
void CGonryunPractice_ProcessCtrl::
CheckGameEnd(playerCharacter_t* pOutPlayer,const enum gameEndType& endType)
{
playerCharacter_t* pLeaderPlayer = NULL;
playerCharacter_t* pOpenentPlayer = NULL;
if( BATTLE_END_RESULT_BORN == endType){
switch(pOutPlayer->GonryunBattlePractice.MemberShip) {
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER:
{
m_Leader.pcIdx = pOutPlayer->idx;
strncpy(m_Leader.ID,pOutPlayer->userID,IDSTRING);
strncpy(m_Leader.Name,pOutPlayer->name,NAMESTRING);
pOpenentPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
if( NULL != pOpenentPlayer) {
m_Winner = m_Openent;
m_Loser = m_Leader;
} else{
m_Winner.pcIdx = -1;
m_Loser = m_Leader;
}
}
break;
case playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT:
{
m_Openent.pcIdx = pOutPlayer->idx;
strncpy(m_Openent.ID,pOutPlayer->userID,IDSTRING);
strncpy(m_Openent.Name,pOutPlayer->name,NAMESTRING);
pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
if( NULL != pLeaderPlayer) {
m_Winner = m_Leader;
m_Loser = m_Openent;
} else{
m_Winner.pcIdx = -1;
m_Loser = m_Openent;
}
}
break;
default:
g_logSystem->Write("BadEndGame PlayerName = %s",pOutPlayer->name);
GTH_DisconnectPlayer(pOutPlayer,FALSE);
return;
}
} else{
pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Leader);
pOpenentPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Openent);
m_Winner.pcIdx = -1;
m_Loser.pcIdx = -1;
}
playerCharacter_t* pWinnerPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Winner);
playerCharacter_t* pLoserPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_Loser);
SetStep(STEP_BATTLE_END);
if( (NULL == pWinnerPlayer) && (NULL == pLoserPlayer) ){
if( NULL != pLeaderPlayer ){
pLeaderPlayer->pvpMode = FALSE;
pLeaderPlayer->GonryunBattlePractice.Record.idraw++;
GTH_SendMessage_CompleteEffect_To_AllPC( pLeaderPlayer, 66 );
if( NULL != pOpenentPlayer ){
m_cpVirtualEncoder->SendGonryunBattleResult(pLeaderPlayer,1,pOpenentPlayer->name);
}
m_cpVirtualEncoder->SendEffect(pLeaderPlayer, PCB_EFF_WIN );
m_cpVirtualEncoder->SendStatus(pLeaderPlayer);
g_DBGameServer->SaveGonryunBattle(pLeaderPlayer);
if(PCB_BATTLE_BATTING == m_BattleType) BattingRestore(pLeaderPlayer);
g_logSystem->Write("DrawEndGame: Name = %s Win = %d Defeat = %d Draw = %d",
pLeaderPlayer->name,
pLeaderPlayer->GonryunBattlePractice.Record.iwin,
pLeaderPlayer->GonryunBattlePractice.Record.idefeat,
pLeaderPlayer->GonryunBattlePractice.Record.idraw);
}
if( NULL != pOpenentPlayer ){
pOpenentPlayer->pvpMode = FALSE;
pOpenentPlayer->GonryunBattlePractice.Record.idraw++;
GTH_SendMessage_CompleteEffect_To_AllPC( pOpenentPlayer, 66 );
if( NULL != pLeaderPlayer ){
m_cpVirtualEncoder->SendGonryunBattleResult(pOpenentPlayer,1,pLeaderPlayer->name);
}
m_cpVirtualEncoder->SendEffect(pOpenentPlayer, PCB_EFF_WIN);
m_cpVirtualEncoder->SendStatus(pOpenentPlayer);
g_DBGameServer->SaveGonryunBattle(pOpenentPlayer);
if(PCB_BATTLE_BATTING == m_BattleType) BattingRestore(pOpenentPlayer);
g_logSystem->Write("DrawEndGame: Name = %s Win = %d Defeat = %d Draw = %d",
pOpenentPlayer->name,
pOpenentPlayer->GonryunBattlePractice.Record.iwin,
pOpenentPlayer->GonryunBattlePractice.Record.idefeat,
pOpenentPlayer->GonryunBattlePractice.Record.idraw);
}
return;
}
if(NULL != pWinnerPlayer){
pWinnerPlayer->pvpMode = FALSE;
GTH_SendMessage_CompleteEffect_To_AllPC( pWinnerPlayer, 66 );
m_cpVirtualEncoder->SendEffect( pWinnerPlayer, PCB_EFF_WIN );
m_cpVirtualEncoder->SendStatus(pWinnerPlayer);
m_cpVirtualRewordCtrl->rewordField( pWinnerPlayer );
pWinnerPlayer->GonryunBattlePractice.Record.iwin++;
g_DBGameServer->SaveGonryunBattle( pWinnerPlayer );
if(NULL != pLoserPlayer){
if(PCB_BATTLE_BATTING == m_BattleType) GiveBattingWinner(pWinnerPlayer, pLoserPlayer);
m_cpVirtualEncoder->SendGonryunBattleResult( pWinnerPlayer,2,pLoserPlayer->name);
}
g_logSystem->Write("EndGame: pWinnerPlayer_Name = %s Win = %d Defeat = %d Draw = %d",
pWinnerPlayer->name,
pWinnerPlayer->GonryunBattlePractice.Record.iwin,
pWinnerPlayer->GonryunBattlePractice.Record.idefeat,
pWinnerPlayer->GonryunBattlePractice.Record.idraw);
}
if(NULL != pLoserPlayer){
pLoserPlayer->pvpMode = FALSE;
GTH_SendMessage_CompleteEffect_To_AllPC( pLoserPlayer, 67 );
m_cpVirtualEncoder->SendEffect( pLoserPlayer, PCB_EFF_DEFEAT );
m_cpVirtualEncoder->SendStatus(pLoserPlayer);
pLoserPlayer->GonryunBattlePractice.Record.idefeat++;
g_DBGameServer->SaveGonryunBattle( pLoserPlayer );
if(NULL != pWinnerPlayer)
m_cpVirtualEncoder->SendGonryunBattleResult( pLoserPlayer,0,pWinnerPlayer->name );
m_cpVirtualEncoder->SendPCEventMessage_DieGonryun( pLoserPlayer);
g_logSystem->Write("EndGame: pLoserPlayer_Name = %s Win = %d Defeat = %d Draw = %d",
pLoserPlayer->name,
pLoserPlayer->GonryunBattlePractice.Record.iwin,
pLoserPlayer->GonryunBattlePractice.Record.idefeat,
pLoserPlayer->GonryunBattlePractice.Record.idraw);
}
}
void CGonryunPractice_ProcessCtrl::BattingRestore( playerCharacter_t* pPlayer )
{
UndoBattingTradeBatting( pPlayer);
m_cpVirtualEncoder->SendMessage_BattingTrade_ExitBatting( pPlayer);
InitTradeBatting( pPlayer );
}
void CGonryunPractice_ProcessCtrl::MakeTransPosition( playerCharacter_t* pLeaderPlayer,playerCharacter_t* pOpenentPlayer )
{
vec3_t leaderposition;
vec3_t openentposition;
if( pLeaderPlayer->worldIdx == ARAYANWORLDMAP ){
gonryunFieldPos_t LeaderPos = g_logic.PCBGonryunCondition.m_tarayanReaderPos;
gonryunFieldPos_t OpenentPos = g_logic.PCBGonryunCondition.m_tarayanOpenentPos;
leaderposition[0]=LeaderPos.m_fbattlein_x;
leaderposition[1]=LeaderPos.m_fbattlein_y;
leaderposition[2]=LeaderPos.m_fbattlein_z;
pLeaderPlayer->angles[1]=LeaderPos.m_fbattlein_yaw;
openentposition[0]=OpenentPos.m_fbattlein_x;
openentposition[1]=OpenentPos.m_fbattlein_y;
openentposition[2]=OpenentPos.m_fbattlein_z;
pOpenentPlayer->angles[1]=OpenentPos.m_fbattlein_yaw;
} else if( pLeaderPlayer->worldIdx == SYENWORDMAP ){
gonryunFieldPos_t LeadersyenPos = g_logic.PCBGonryunCondition.m_tasyenReaderPos;
gonryunFieldPos_t OpenentsyenPos = g_logic.PCBGonryunCondition.m_tasyenOpenentPos;
leaderposition[0]=LeadersyenPos.m_fbattlein_x;
leaderposition[1]=LeadersyenPos.m_fbattlein_y;
leaderposition[2]=LeadersyenPos.m_fbattlein_z;
pLeaderPlayer->angles[1]=LeadersyenPos.m_fbattlein_yaw;
openentposition[0]=OpenentsyenPos.m_fbattlein_x;
openentposition[1]=OpenentsyenPos.m_fbattlein_y;
openentposition[2]=OpenentsyenPos.m_fbattlein_z;
pOpenentPlayer->angles[1]=OpenentsyenPos.m_fbattlein_yaw;
}
MakeTransPort( pLeaderPlayer,leaderposition );
MakeTransPort( pOpenentPlayer,openentposition );
}
void CGonryunPractice_ProcessCtrl::SetActive(const int& active)
{
m_bIsactive = active;
}
const int& CGonryunPractice_ProcessCtrl::GetActive(void)const
{
return m_bIsactive;
}
const CGonryunPractice_ProcessCtrl::Step& CGonryunPractice_ProcessCtrl::GetStep(void)const
{
return m_Step;
}
void CGonryunPractice_ProcessCtrl::SetBattleType(const battleMode& type)
{
m_BattleType = type;
}
const CGonryunPractice_ProcessCtrl::battleMode& CGonryunPractice_ProcessCtrl::GetBattleType()const
{
return m_BattleType;
}
void CGonryunPractice_ProcessCtrl::SetLeader( playerCharacter_t* pLeaderPlayer)
{
m_Leader.pcIdx = pLeaderPlayer->idx;
strncpy(m_Leader.ID,pLeaderPlayer->userID,IDSTRING);
m_Leader.ID[IDSTRING] = NULL;
strncpy(m_Leader.Name,pLeaderPlayer->name,NAMESTRING);
m_Leader.Name[NAMESTRING] = NULL;
pLeaderPlayer->GonryunBattlePractice.MemberShip =
playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER;
}
void CGonryunPractice_ProcessCtrl::SetOpenent( playerCharacter_t* pOpenetPlayer)
{
m_Openent.pcIdx = pOpenetPlayer->idx;
strncpy(m_Openent.ID,pOpenetPlayer->userID,IDSTRING);
m_Openent.ID[IDSTRING] = NULL;
strncpy(m_Openent.Name,pOpenetPlayer->name,NAMESTRING);
m_Openent.Name[NAMESTRING] = NULL;
pOpenetPlayer->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT;
}
void CGonryunPractice_ProcessCtrl::SetBattingBattle(const BOOL bvalue)
{
m_bIsBattleBatting=bvalue;
}
BOOL CGonryunPractice_ProcessCtrl::isBattingPlayActive(void) const
{
return m_bIsBattleBatting;
}
BOOL CGonryunPractice_ProcessCtrl::CheckItemInformation( playerCharacter_t* pPlayer, const int checkType )
{
int ownItemTableIndex = -1;
int ownItemNumber = -1;
for(int inventoryIdx = 0; inventoryIdx < MAX_INVENTORY_SIZE; inventoryIdx++){
ownItemTableIndex = pPlayer->inventory[inventoryIdx];
if( 0 > ownItemTableIndex) continue;
if( 0 <= pPlayer->item[ownItemTableIndex].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"InventoryItem Data Error!! checkType = %d UserName = %s InventoryIdx = %d ItemIdx = %d",
pPlayer->name,
inventoryIdx ,
ownItemTableIndex );
}
}
for(int equipmentIdx = 0; equipmentIdx < MAX_EQUIPMENT; equipmentIdx++ ){
ownItemTableIndex = pPlayer->equipment[equipmentIdx];
if( 0 > ownItemTableIndex) continue;
if( 0 <= pPlayer->item[ownItemTableIndex].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"equipment Data Error!! checkType = %d UserName = %s InventoryIdx = %d ItemIdx = %d",
pPlayer->name,
equipmentIdx ,
ownItemTableIndex );
}
}
for(int depotIdx = 0; depotIdx < MAX_DEPOT_SIZE; depotIdx++ ){
ownItemTableIndex = pPlayer->depot[depotIdx];
if( 0 > ownItemTableIndex) continue;
if( 0 <= pPlayer->item[ownItemTableIndex].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"depot Data Error!! checkType = %d UserName = %s InventoryIdx = %d ItemIdx = %d",
pPlayer->name,
depotIdx ,
ownItemTableIndex );
}
}
for( int precocityIdx = 0; precocityIdx < MAX_PRECOCITY_SIZE; precocityIdx ++ ){
ownItemTableIndex = pPlayer->precocityInventory[precocityIdx];
if( 0 > ownItemTableIndex) continue;
if( 0 <= pPlayer->item[ownItemTableIndex].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"precocityInventory Data Error!! checkType = %d UserName = %s InventoryIdx = %d ItemIdx = %d",
pPlayer->name,
precocityIdx ,
ownItemTableIndex );
}
}
for(int GBPinventory = 0; GBPinventory < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPinventory++)
{
ownItemTableIndex = pPlayer->GonryunBattlePractice.Inventory[GBPinventory];
if( 0 > ownItemTableIndex) continue;
if( 0 <= pPlayer->item[ownItemTableIndex].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"GBPinventory Data Error!! checkType = %d UserName = %s InventoryIdx = %d ItemIdx = %d",
pPlayer->name,
GBPinventory ,
ownItemTableIndex );
}
}
if( 0 <= pPlayer->mouseInventory){
if( 0 <= pPlayer->item[pPlayer->mouseInventory].itemTableIdx ){
ownItemNumber++;
} else{
g_logSystem->Write(
"mouseInventory Data Error!! checkType = %d UserName = %s ItemIdx = %d",
pPlayer->name,
pPlayer->mouseInventory );
}
}
return (ownItemNumber == pPlayer->itemNumber) ? TRUE: FALSE;
}
void CGonryunPractice_ProcessCtrl::InitNoticePC( playerCharacter_t* pPlayer )
{
pPlayer->busyState = BUSY_STATE_NONE;
pPlayer->GonryunBattlePractice.MemberShip = playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_NONE;
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
}
void CGonryunPractice_ProcessCtrl::CheckPlayerPos_and_Transport(playerCharacter_t* pPlayer)
{
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER == pPlayer->GonryunBattlePractice.MemberShip) ||
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT == pPlayer->GonryunBattlePractice.MemberShip))
return;
vec3_t position;
if( pPlayer->worldIdx == ARAYANWORLDMAP ) {
if ( GTH_GetDistance2D(g_logic.PCBGonryunCondition.origin_ArayanOutPos,pPlayer->position) <= g_logic.PCBGonryunCondition.pcpBattleIn ){
if( FALSE == pPlayer->pvpMode){
position[0] = g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_x;
position[1] = g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_y;
position[2] = g_logic.PCBGonryunCondition.m_tarayanwinnerOutPos.m_fbattlein_z;
MakeTransPort(pPlayer,position);
g_logSystem->Write("CheckPlayerPos_and_Transport Spawn pPlayer name=%s STATE = %d WorldIdx = %d pos.x=%f,pos.y=%f,pos.z=%f",
pPlayer->name,
pPlayer->GonryunBattlePractice.PC_State,
pPlayer->worldIdx,
pPlayer->position[0],
pPlayer->position[1],
pPlayer->position[2]);
} else{
GTH_DisconnectPlayer(pPlayer,FALSE);
}
}
}
else if( pPlayer->worldIdx== SYENWORDMAP ) {
if ( GTH_GetDistance2D(g_logic.PCBGonryunCondition.origin_syenOutPos,pPlayer->position) <= g_logic.PCBGonryunCondition.pcpBattleIn ){
if(FALSE == pPlayer->pvpMode){
position[0] = g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_x;
position[1] = g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_y;
position[2] = g_logic.PCBGonryunCondition.m_tsyenOutPos.m_fbattlein_z;
MakeTransPort(pPlayer,position);
g_logSystem->Write("CheckPlayerPos_and_Transport Spawn pPlayer name=%s STATE = %d WorldIdx = %d pos.x=%f,pos.y=%f,pos.z=%f",
pPlayer->name,
pPlayer->GonryunBattlePractice.PC_State,
pPlayer->worldIdx,
pPlayer->position[0],
pPlayer->position[1],
pPlayer->position[2]);
} else{
GTH_DisconnectPlayer(pPlayer,FALSE);
}
}
}
}
const tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode CGonryunPractice_ProcessCtrl::
CheckConfirmTradeBatting(playerCharacter_t* pToPlayer,playerCharacter_t* pFromPlayer)
{
class CTempPlayerInventoryX TempInventory(pToPlayer);
int playerItemArrayIdx = -1;
const item_t* pItem = NULL;
for(int GBPInventoryIdx = 0; GBPInventoryIdx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPInventoryIdx++){
playerItemArrayIdx = pFromPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx];
if( (0 > playerItemArrayIdx) || ( playerItemArrayIdx >= MAX_NUMBER_OF_OWNITEM) ) continue;
pItem = &pFromPlayer->item[playerItemArrayIdx];
if( NULL == pItem) continue;
if( (0 > pItem->itemTableIdx) || ( pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) ) continue;
switch(TempInventory.Insert(pItem)) {
case CTempPlayerInventoryX::ErrorCode_Success:
break;
case CTempPlayerInventoryX::ErrorCode_Over_Weight:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_Weight_Over;
case CTempPlayerInventoryX::ErrorCode_stacknum_overflow:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ErrorCode_stacknum_overflow;
case CTempPlayerInventoryX::ErrorCode_NotEnough_Inventory:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_NotEnough_InventorySpace;
case CTempPlayerInventoryX::ErrorCode_unknown:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ErrorCode_unknown;
}
}
for(GBPInventoryIdx = 0; GBPInventoryIdx < playerCharacter_t::tagGonryunBattlePractice::MAX_GBP_INVENTORY_SIZE; GBPInventoryIdx++){
playerItemArrayIdx = pToPlayer->GonryunBattlePractice.Inventory[GBPInventoryIdx];
if( (0 > playerItemArrayIdx) || ( playerItemArrayIdx >= MAX_NUMBER_OF_OWNITEM) ) continue;
pItem = &pToPlayer->item[playerItemArrayIdx];
if( NULL == pItem) continue;
if( (0 > pItem->itemTableIdx) || ( pItem->itemTableIdx >= MAX_NUMBER_OF_ITEM_TABLE) ) continue;
switch(TempInventory.Insert(pItem)) {
case CTempPlayerInventoryX::ErrorCode_Success:
break;
case CTempPlayerInventoryX::ErrorCode_Over_Weight:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_Weight_Over;
case CTempPlayerInventoryX::ErrorCode_stacknum_overflow:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ErrorCode_stacknum_overflow;
case CTempPlayerInventoryX::ErrorCode_NotEnough_Inventory:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ERROR_NotEnough_InventorySpace;
case CTempPlayerInventoryX::ErrorCode_unknown:
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::ErrorCode_unknown;
}
}
return tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::success;
}
| C++ |
#include "..\global.h"
#include "CGonryunPractice_Ability.h"
CGonryunPractice_Ability::CGonryunPractice_Ability()
{
Init();
}
CGonryunPractice_Ability::CGonryunPractice_Ability(const CGonryunPractice_Ability& rReword)
{
m_irewordID = rReword.m_irewordID;
strncpy(m_szrewordName , rReword.m_szrewordName,NAMEARRAY);
m_szrewordName[NAMEARRAY] = NULL;
m_irewordType = rReword.m_irewordType;
m_irewordExperience = rReword.m_irewordExperience;
m_irewordExperienceRate = rReword.m_irewordExperienceRate;
m_irewordItemID = rReword.m_irewordItemID;
m_irewordItemRate = rReword.m_irewordItemRate;
}
CGonryunPractice_Ability& CGonryunPractice_Ability::operator = (const CGonryunPractice_Ability& rReword)
{
m_irewordID = rReword.m_irewordID;
strncpy(m_szrewordName , rReword.m_szrewordName,NAMEARRAY);
m_szrewordName[NAMEARRAY] = NULL;
m_irewordType = rReword.m_irewordType;
m_irewordExperience = rReword.m_irewordExperience;
m_irewordExperienceRate = rReword.m_irewordExperienceRate;
m_irewordItemID = rReword.m_irewordItemID;
m_irewordItemRate = rReword.m_irewordItemRate;
return *this;
}
void CGonryunPractice_Ability::Init()
{
m_irewordID = 0;
m_szrewordName[0] = NULL;
m_irewordType = 0;
m_irewordExperience = 0;
m_irewordExperienceRate = 0;
m_irewordItemID = 0;
m_irewordItemRate = 0;
}
void CGonryunPractice_Ability::SetID(const int& id)
{
m_irewordID = id;
}
const int& CGonryunPractice_Ability::GetID()const
{
return m_irewordID;
}
BOOL CGonryunPractice_Ability::SetName(const char* pname)
{
if(FALSE == IsvalidNameLength(pname)) return FALSE;
strncpy(m_szrewordName,pname,NAMEARRAY);
m_szrewordName[NAMEARRAY] = NULL;
return TRUE;
}
const char* CGonryunPractice_Ability::GetName()const
{
return m_szrewordName;
}
void CGonryunPractice_Ability::SetType(const int& type)
{
m_irewordType = type;
}
const int& CGonryunPractice_Ability::GetType()const
{
return m_irewordType;
}
void CGonryunPractice_Ability::SetExperience(const int& Experience)
{
m_irewordExperience = Experience;
}
const int& CGonryunPractice_Ability::GetExperience()const
{
return m_irewordExperience;
}
void CGonryunPractice_Ability::SetExpRate(const int& ExpRate)
{
m_irewordExperienceRate = ExpRate;
}
const int& CGonryunPractice_Ability::GetExpRate()const
{
return m_irewordExperienceRate;
}
void CGonryunPractice_Ability::SetItemID(const int& itemID)
{
m_irewordItemID = itemID;
}
const int& CGonryunPractice_Ability::GetItemID()const
{
return m_irewordItemID;
}
void CGonryunPractice_Ability::SetItemRate(const int& itemRate)
{
m_irewordItemRate = itemRate;
}
const int& CGonryunPractice_Ability::GetItemRate()const
{
return m_irewordItemRate;
}
BOOL CGonryunPractice_Ability::IsvalidNameLength(const char* pname)const
{
int length = strlen(pname);
return (( 0 < length ) && ( NAMEARRAY >= length ) ) ? TRUE : FALSE;
} | C++ |
#ifndef _CGONRYUNPRACTICE_REWORDCTRL_H_
#define _CGONRYUNPRACTICE_REWORDCTRL_H_
#include <List>
using namespace std;
class CGonryunPractice_Ability;
class CGonryunPractice_RewordItem;
class CGonryunPractice_ProcessCtrl;
class CGonryunPractice_WaiterCtrl;
class CGonryunPracticeBattle;
class CGonryunPractice_ProcessCtrl;
class CGonryunPractice_RewordCtrl
{
public:
enum enumLevelValue{
LEVEL_FIFTEEN = 15,
LEVEL_THIRTY = 30,
};
private:
typedef std::list<CGonryunPractice_RewordItem*> REWORDITEMLIST;
typedef REWORDITEMLIST::iterator REWORDITEM_ITOR;
REWORDITEMLIST m_rewordItemList;
typedef std::list<CGonryunPractice_Ability*> REWORDLIST;
typedef REWORDLIST::iterator REWORD_ITOR;
REWORDLIST m_rewordList;
private:
BOOL m_bOK;
CGonryunPractice_ProcessCtrl* m_cpVirtualProcessCtrl;
CGonryunPractice_Encoder* m_cpVirtualEncoder;
public:
CGonryunPractice_RewordCtrl();
virtual~CGonryunPractice_RewordCtrl();
public:
BOOL isOK(void);
void Set(CGonryunPracticeBattle* pPracticeBattle);
CGonryunPractice_Ability* GetReword(const int Idx);
void rewordField(playerCharacter_t *puser);
REWORDITEMLIST& GetRewordItemList();
REWORDLIST& GetRewordList();
CGonryunPractice_ProcessCtrl* GetProcessCtrl();
private:
void GetLootByBattleReword(playerCharacter_t* pPlayer, __int64 exp,__int64 genExp);
void addItemBattleField(void *pPc, int *pParam );
BOOL addItemBattle(playerCharacter_t *puser);
void Destroy(void);
void ExpUp_Player(playerCharacter_t* pPlayer,int& exp, int& genExp,int& level,int& genLevel );
};
#endif | C++ |
#include "..\global.h"
#include "CGonryunPractice_RewordItem.h"
CGonryunPractice_RewordItem::CGonryunPractice_RewordItem()
{
Init();
}
CGonryunPractice_RewordItem::CGonryunPractice_RewordItem(const CGonryunPractice_RewordItem& rRewordItem)
{
m_irewordItemIndex = rRewordItem.m_irewordItemIndex;
m_irewordItemType = rRewordItem.m_irewordItemType;
m_irewordItemNumber = rRewordItem.m_irewordItemNumber;
m_irewordItemRate = rRewordItem.m_irewordItemRate;
m_irewordItemCount = rRewordItem.m_irewordItemCount;
}
CGonryunPractice_RewordItem& CGonryunPractice_RewordItem::operator = (const CGonryunPractice_RewordItem& rRewordItem)
{
m_irewordItemIndex = rRewordItem.m_irewordItemIndex;
m_irewordItemType = rRewordItem.m_irewordItemType;
m_irewordItemNumber = rRewordItem.m_irewordItemNumber;
m_irewordItemRate = rRewordItem.m_irewordItemRate;
m_irewordItemCount = rRewordItem.m_irewordItemCount;
return *this;
}
void CGonryunPractice_RewordItem::Init()
{
m_irewordItemIndex = 0;
m_irewordItemType = 0;
m_irewordItemNumber = 0;
m_irewordItemRate = 0;
m_irewordItemCount = 0;
}
void CGonryunPractice_RewordItem::SetItemIndex(const int& index)
{
m_irewordItemIndex = index;
}
const int& CGonryunPractice_RewordItem::GetItemIndex()const
{
return m_irewordItemIndex;
}
void CGonryunPractice_RewordItem::SetItemType(const int& type)
{
m_irewordItemType = type;
}
const int& CGonryunPractice_RewordItem::GetItemType()const
{
return m_irewordItemType;
}
void CGonryunPractice_RewordItem::SetItemNumber(const int& number)
{
m_irewordItemNumber = number;
}
const int& CGonryunPractice_RewordItem::GetItemNumber() const
{
return m_irewordItemNumber;
}
void CGonryunPractice_RewordItem::SetItemRate(const int& rate)
{
m_irewordItemRate = rate;
}
const int& CGonryunPractice_RewordItem::GetItemRate() const
{
return m_irewordItemRate;
}
void CGonryunPractice_RewordItem::SetItemCount(const int& count)
{
m_irewordItemCount = count;
}
const int& CGonryunPractice_RewordItem::GetItemCount() const
{
return m_irewordItemCount;
} | C++ |
#ifndef _CGONRYUNPRACTICE_PROCESSCTRL_H_
#define _CGONRYUNPRACTICE_PROCESSCTRL_H_
class CGonryunPracticeBattle;
class CGonryunPractice_WaiterCtrl;
class CGonryunPractice_RewordCtrl;
class CGonryunPractice_Encoder;
#include "tagGonryunPractice.h"
#include "tagGonryunPracticePacket.h"
class CGonryunPractice_ProcessCtrl{
public:
enum _define{
MAX_WAIT_USER = 20,
ARAYANWORLDMAP = 0,
SYENWORDMAP = 9,
MAX_OVERFLOW = 0,
};
enum efffecmode{
PCB_EFF_NONE =0,
PCB_EFF_READY,
PCB_EFF_WIN,
PCB_EFF_DRAW,
PCB_EFF_DEFEAT,
};
enum Step{
STEP_NONE=0,
STEP_SUGGUEST,
STEP_BATTING,
STEP_BATTLE_READY,
STEP_BATTLE_COUNTDOWN,
STEP_FIGHTING,
STEP_BATTLE_END,
STEP_MAX,
};
enum battleMode{
PCB_BATTLE_NONE = 0,
PCB_BATTLE_NORMAL = 1,
PCB_BATTLE_BATTING = 2,
};
enum gameEndType{
BATTLE_END_DRAW = 0,
BATTLE_END_RESULT_BORN = 1,
};
enum confirmState{
Confirm_None = 0,
Confirm_Admit = 1,
Confirm_Win = 2,
Confirm_Defeate = 3,
Confirm_Fail = 4,
};
public:
CGonryunPractice_ProcessCtrl();
virtual ~CGonryunPractice_ProcessCtrl(){}
public:
BOOL isOK(void);
void Init(void);
void Set(CGonryunPracticeBattle* pPracticeBattle);
BOOL SuggestPlayer(playerCharacter_t* pSuggestPlayer);
void SetActive(const int& active);
const int& GetActive(void)const;
void SetStep(const Step& step);
const enum Step& GetStep(void)const;
void MakeTransPosition(playerCharacter_t* pLeaderPlayer,playerCharacter_t* pOpenentPlayer);
void MakeTransPort(playerCharacter_t* pc,const vec3_t leaderposition);
void SetBattleType(const battleMode& type);
const battleMode& GetBattleType()const;
void SetLeader( playerCharacter_t* pLeaderPlayer);
void SetOpenent(playerCharacter_t* Waiter);
void IrregularQuitBattle(playerCharacter_t* pOutPlayer);
void IrregularQuitBattle_Suggent(playerCharacter_t* pOutPlayer);
void IrregularQuitBattle_Batting(playerCharacter_t* pOutPlayer);
void IrregularQuitBattle_Fighting(playerCharacter_t* pOutPlayer);
void IrregularQuitBattle_End(playerCharacter_t* pOutPlayer);
void Update(void);
void CheckGameEnd(playerCharacter_t* pOutPlayer,const enum gameEndType& endType);
void InitTradeBatting( playerCharacter_t* pc );
int UndoBattingTradeBatting(playerCharacter_t* pPlayer);
void BattingRestore(playerCharacter_t* pOutPlayer);
void SetBattingBattle(const BOOL bvalue);
BOOL isBattingPlayActive(void) const;
void InitNoticePC( playerCharacter_t* pPlayer );
void CheckPlayerPos_and_Transport(playerCharacter_t* pPlayer);
const tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode
CheckConfirmTradeBatting(
playerCharacter_t *pPlayer,
playerCharacter_t* pOpenent);
private:
void CheckNormalGameEnd(playerCharacter_t* pWinner,playerCharacter_t* pDefeator);
void CheckBattingGameEnd(playerCharacter_t* pWinner,playerCharacter_t* pDefeator);
void CheckOverFlowUseCount(playerCharacter_t* pPlayer);
void CheckAndMove(void);
int DeleteBattingItem(playerCharacter_t* pdefeator);
void GetWinnerPortalPos(playerCharacter_t* pPlayer);
void GeLoserPortalPos(playerCharacter_t* pLoserPlayer);
void GiveBattingWinner(playerCharacter_t *pwinor,playerCharacter_t *pdefeator);
void ConfirmTradeBattingWinerGive(
playerCharacter_t *pwinor,
playerCharacter_t *pdefeator);
inline void ConfirmTradeBattingWinerGive_Item(
playerCharacter_t* pwinor,
playerCharacter_t* pdefeator);
void Update_Sugguest(const int time);
void Update_Batting(const int Time);
void Update_Battle_Ready(const int Time);
void Update_Fighting(const int Time);
void Update_Battle_End(const int Time);
playerCharacter_t* GetPlayerPointer(const struct tagGPWaitUser& Fighter) const;
BOOL CheckItemInformation( playerCharacter_t* pPlayer,const int checkType = 0 );
private:
enum Step m_Step;
DWORD m_dwStatusStartTime;
BOOL m_bIsactive;
enum battleMode m_BattleType;
BOOL m_bOK;
BOOL m_bIsBattleBatting;
private:
CGonryunPractice_WaiterCtrl* m_cpVirtualWaiterCtrl;
CGonryunPractice_RewordCtrl* m_cpVirtualRewordCtrl;
CGonryunPractice_Encoder* m_cpVirtualEncoder;
public:
struct tagGPWaitUser m_Leader;
struct tagGPWaitUser m_Openent;
struct tagGPWaitUser m_Winner;
struct tagGPWaitUser m_Loser;
};
#endif | C++ |
#ifndef _CGONRYUNPRACTICEBATTLE_H_
#define _CGONRYUNPRACTICEBATTLE_H_
class CGonryunPractice_ProcessCtrl;
class CGonryunPractice_WaiterCtrl;
class CGonryunPractice_RewordCtrl;
class CGonryunPractice_Decoder;
class CGonryunPractice_Encoder;
class CGonryunPracticeBattle{
private:
BOOL m_bOK;
CGonryunPractice_ProcessCtrl* m_cpProcessCtrl;
CGonryunPractice_WaiterCtrl* m_cpWaiterCtrl;
CGonryunPractice_RewordCtrl* m_cpRewordCtrl;
CGonryunPractice_Decoder* m_cpDecoder;
CGonryunPractice_Encoder* m_cpEncoder;
private:
BOOL Init(void);
public:
int NPCClick(playerCharacter_t* pPlayer);
CGonryunPractice_ProcessCtrl* GetProcessCtrl(void);
CGonryunPractice_WaiterCtrl* GetWaiterCtrl(void);
CGonryunPractice_Encoder* GetEncoder(void);
CGonryunPractice_RewordCtrl* GetRewordCtrl(void);
CGonryunPractice_Decoder* GetDecoder(void);
public:
CGonryunPracticeBattle();
virtual ~CGonryunPracticeBattle();
};
#endif | C++ |
#include "..\global.h"
#include "CGonryunPracticeBattle.h"
#include "CGonryunPractice_ProcessCtrl.h"
#include "CGonryunPractice_WaiterCtrl.h"
#include "CGonryunPractice_Encoder.h"
#include "tagGonryunPracticePacket.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CGonryunPractice_Encoder::CGonryunPractice_Encoder()
{
m_bOK=FALSE;
m_cpVirtualPracticeBattle = NULL;
m_cpVirtualProcessCtrl = NULL;
m_cpVirtualWaiterCtrl = NULL;
m_bOK=TRUE;
}
CGonryunPractice_Encoder::~CGonryunPractice_Encoder()
{
}
BOOL CGonryunPractice_Encoder::isOK(void)
{
return m_bOK;
}
void CGonryunPractice_Encoder::Set(CGonryunPracticeBattle* pPracticeBattle)
{
m_cpVirtualPracticeBattle = pPracticeBattle;
m_cpVirtualProcessCtrl = pPracticeBattle->GetProcessCtrl();
m_cpVirtualWaiterCtrl = pPracticeBattle->GetWaiterCtrl();
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_ItemBatting(
playerCharacter_t* pPlayer,
BOOL bMyItem,
enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_ITEM::enumType Type,
int pos,
item_t *item,
const int DeleteItemIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_ITEM);
MSG_WriteByte(&netMessage, bMyItem);
MSG_WriteByte(&netMessage, Type);
MSG_WriteByte(&netMessage, pos);
MSG_WriteItem(&netMessage, item);
MSG_WriteShort(&netMessage, DeleteItemIdx);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendWaitUserBattleEnd(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_END);
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendWaitUserBattleEnd(void)
{
CGonryunPractice_WaiterCtrl::WAIT_ITOR itor;
struct tagGPWaitUser WaitUser;
for(itor = (m_cpVirtualWaiterCtrl->m_WaitUserList).begin();itor != (m_cpVirtualWaiterCtrl->m_WaitUserList).end(); itor++ ){
WaitUser = *itor;
playerCharacter_t* pPlayer = m_cpVirtualWaiterCtrl->GetWaiter(WaitUser);
if( NULL == pPlayer) continue;
SendWaitUserBattleEnd(pPlayer);
}
}
void CGonryunPractice_Encoder::SendStatus(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_STATE);
MSG_WriteShort(&netMessage,m_cpVirtualProcessCtrl->GetStep());
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendEffect(playerCharacter_t* pPlayer,int type)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_EFFECT_MODE);
MSG_WriteShort(&netMessage,type);
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendGonryunBattleInfo(playerCharacter_t* pToPlayer,const int time)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_INFO);
MSG_WriteLong(&netMessage, time);
NET_SendMessage ( &(pToPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendGonryunBattleResult(playerCharacter_t* pPlayer,int result,char* pname)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_RESULT);
MSG_WriteByte(&netMessage, result);
MSG_WriteString(&netMessage,pname);
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting( &netMessage );
}
void CGonryunPractice_Encoder::SendMessage_NormalReject_toPlayer(playerCharacter_t* pLeaderPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_GENERATE_REJECT);
NET_SendMessage ( &pLeaderPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendMessageBattleReject( playerCharacter_t* pLeaderPlayer )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTING_REJECT);
NET_SendMessage ( &pLeaderPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendBattleMsg(
playerCharacter_t* pPlayer,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::enumCode Code,
const int Value1,
const int Value2,
const int Value3) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_MSG);
MSG_WriteLong(&netMessage, Code);
MSG_WriteLong(&netMessage, Value1);
MSG_WriteLong(&netMessage, Value2);
MSG_WriteLong(&netMessage, Value3);
NET_SendMessage ( &pPlayer->sock , &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendMessageNake(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_NAKE_RESULT);
MSG_WriteLong(&netMessage, pPlayer->curChargeSE);
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendReqeust_NomalBattle_toOpenent(
const int LeaderPCIdx,
char* szpLeaderName,
playerCharacter_t* pOpenentPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_REQUEST_BATTELGENERATE);
MSG_WriteLong(&netMessage,LeaderPCIdx);
MSG_WriteString(&netMessage,szpLeaderName);
NET_SendMessage ( &pOpenentPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendWaitUserList(playerCharacter_t* pLeaderPlayer,playerCharacter_t* pToPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_GET_OTHERLISTINFO);
MSG_WriteByte(&netMessage,m_cpVirtualWaiterCtrl->GetNum()+1);
MSG_WriteByte(&netMessage,g_logic.PCBGonryunCondition.m_idifferLevel);
MSG_WriteString(&netMessage,pLeaderPlayer->name);
MSG_WriteShort(&netMessage, TRUE);
MSG_WriteByte(&netMessage, pLeaderPlayer->GonryunBattlePractice.Record.iwin);
MSG_WriteByte(&netMessage, pLeaderPlayer->GonryunBattlePractice.Record.idraw);
MSG_WriteByte(&netMessage, pLeaderPlayer->GonryunBattlePractice.Record.idefeat);
MSG_WriteByte(&netMessage, pLeaderPlayer->level);
CGonryunPractice_WaiterCtrl::WAIT_ITOR itor;
playerCharacter_t* pWaitPlayer = NULL;
for( itor = (m_cpVirtualWaiterCtrl->m_WaitUserList).begin(); itor != (m_cpVirtualWaiterCtrl->m_WaitUserList).end(); itor++ ){
pWaitPlayer = m_cpVirtualWaiterCtrl->GetWaiter(*itor);
if(NULL == pWaitPlayer ) continue;
MSG_WriteString(&netMessage,pWaitPlayer->name);
MSG_WriteShort(&netMessage, FALSE);
MSG_WriteByte(&netMessage, pWaitPlayer->GonryunBattlePractice.Record.iwin);
MSG_WriteByte(&netMessage, pWaitPlayer->GonryunBattlePractice.Record.idraw);
MSG_WriteByte(&netMessage, pWaitPlayer->GonryunBattlePractice.Record.idefeat);
MSG_WriteByte(&netMessage, pWaitPlayer->level);
}
NET_SendMessage( &pToPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMyInfoToUser(
playerCharacter_t* pLeaderPlayer,
playerCharacter_t* pSuggestPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_MYINFO_TOUSER);
MSG_WriteString(&netMessage,pSuggestPlayer->name);
MSG_WriteByte(&netMessage, pSuggestPlayer->GonryunBattlePractice.Record.iwin);
MSG_WriteByte(&netMessage, pSuggestPlayer->GonryunBattlePractice.Record.idraw);
MSG_WriteByte(&netMessage, pSuggestPlayer->GonryunBattlePractice.Record.idefeat);
MSG_WriteByte(&netMessage, pSuggestPlayer->level);
NET_SendMessage( &pLeaderPlayer->sock, &netMessage);
CGonryunPractice_WaiterCtrl::WAIT_ITOR itor;
playerCharacter_t* pWaitPlayer = NULL;
for( itor = (m_cpVirtualWaiterCtrl->m_WaitUserList).begin(); itor != (m_cpVirtualWaiterCtrl->m_WaitUserList).end(); itor++ ){
pWaitPlayer = m_cpVirtualWaiterCtrl->GetWaiter(*itor);
if(NULL == pWaitPlayer ) continue;
if(pSuggestPlayer == pWaitPlayer) continue;
NET_SendMessage( &pWaitPlayer->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::SendDeleteUser(playerCharacter_t* pPlayer)
{
playerCharacter_t* pLeaderPlayer = m_cpVirtualWaiterCtrl->GetWaiter(m_cpVirtualProcessCtrl->m_Leader);
if( NULL == pLeaderPlayer )
{
SendWaitUserBattleEnd();
m_cpVirtualProcessCtrl->Init();
return;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_DELETE_USER);
MSG_WriteString(&netMessage,pPlayer->name);
NET_SendMessage( &pLeaderPlayer->sock, &netMessage);
CGonryunPractice_WaiterCtrl::WAIT_ITOR itor;
playerCharacter_t* pWaitPlayer = NULL;
for( itor = (m_cpVirtualWaiterCtrl->m_WaitUserList).begin(); itor != (m_cpVirtualWaiterCtrl->m_WaitUserList).end(); itor++ ){
pWaitPlayer = m_cpVirtualWaiterCtrl->GetWaiter(*itor);
if(NULL == pWaitPlayer ) continue;
if( 0 == strncmp(pWaitPlayer->name,pPlayer->name,NAMESTRING)) continue;
NET_SendMessage( &pWaitPlayer->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_OkBatting( playerCharacter_t* pPlayer, BOOL type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_OK);
MSG_WriteByte( &netMessage, type );
NET_SendMessage( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_RequestBatting( playerCharacter_t* pPlayer, playerCharacter_t* ptarget, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_REQUEST);
MSG_WriteShort(&netMessage, ptarget->idx);
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, ptarget->name );
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_AdmitBatting( playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_RESULT);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_RejectBatting( playerCharacter_t* player, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_REJECT);
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&player->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_ExitBatting( playerCharacter_t* player)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_EXIT);
NET_SendMessage(&player->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_CancelBatting( playerCharacter_t* player, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_CANCEL);
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&player->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_ConfirmBatting(
playerCharacter_t* player,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::enumState& state,
const enum tagGonryunPracticePacket_BATTLE_PRACTICE_BATTINGTRADE_CONFIRM::errorCode& Code)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_CONFIRM);
MSG_WriteByte(&netMessage, state);
MSG_WriteByte(&netMessage, Code);
NET_SendMessage(&player->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGonryunPractice_Encoder::
SendMessage_BattingTrade_SEBatting( playerCharacter_t* player, int error, int type, int se )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BATTINGTRADE_SE);
MSG_WriteByte(&netMessage, type);
MSG_WriteLong(&netMessage, se);
MSG_WriteByte(&netMessage, error);
NET_SendMessage(&player->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
CGonryunPracticeBattle* CGonryunPractice_Encoder::GetPracticeBattlePointer()const
{
return m_cpVirtualPracticeBattle;
}
CGonryunPractice_ProcessCtrl* CGonryunPractice_Encoder::GetProcessCtrl()const
{
return m_cpVirtualProcessCtrl;
}
void CGonryunPractice_Encoder::SendMessage_Open(playerCharacter_t* pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_ANSWER_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_OPEN);
MSG_WriteLong(&netMessage, g_logic.PCBGonryunCondition.m_iroyalty);
MSG_WriteLong(&netMessage, g_logic.PCBGonryunCondition.m_ibattingRoyalty);
NET_SendMessage(&(pPlayer->sock), &netMessage);
}
MSG_EndWriting(&netMessage);
}
int CGonryunPractice_Encoder::SendPCEventMessage_DieGonryun( playerCharacter_t* pPlayer )
{
playerCharacter_t* pTarketPlayer = NULL;
GTH_GetPCListInValidRange(pPlayer->worldIdx, pPlayer->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_DIE);
MSG_WriteShort(&netMessage, pPlayer->idx);
MSG_WriteByte(&netMessage, pPlayer->entityType);
MSG_WriteShort(&netMessage, pPlayer->curDamage);
MSG_WriteByte(&netMessage, pPlayer->lastAttackState);
MSG_WriteShort(&netMessage, pPlayer->killerIdx);
MSG_WriteByte(&netMessage, pPlayer->killerType);
MSG_Write64Int(&netMessage, pPlayer->exp );
MSG_WriteLong(&netMessage, pPlayer->curChargeSE);
MSG_WriteShort(&netMessage, -1);
MSG_WriteShort(&netMessage, 0);
for (int i=0; i < g_zonePCListNumber; i++)
{
pTarketPlayer = gcpTools->GetPlayerRecordPointer(g_zonePCList[i].idx);
if ( NULL == pTarketPlayer ) continue;
NET_SendUnreliableMessage(&pTarketPlayer->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return 1;
}
| C++ |
#include "../global.h"
extern AIFUNC AI_NPC_FUNC[];
int AI_NPC_InterpretorFunction( playerCharacter_t* pc )
{
int param[5];
int variable = false;
int paramAddr;
int argCount;
paramAddr = AI_NPC_GetCharData( pc );
argCount = AI_NPC_FUNC[paramAddr].argCount;
if ( argCount > 0 )
AI_NPC_InterpretorParameter( pc, param, argCount );
variable = AI_NPC_FUNC[paramAddr].pFunc( pc, param );
return( variable );
}
int AI_NPC_InterpretorDefine( playerCharacter_t* pc, int paramAddr )
{
int variable;
switch( paramAddr )
{
case 0 :
variable = true;
break;
case 1 :
variable = false;
break;
case 2 :
variable = J_MENTALITY;
break;
case 3 :
variable = J_WIND;
break;
case 4 :
variable = J_WATER;
break;
case 5 :
variable = J_EARTH;
break;
case 6 :
variable = J_DEVOTIONAL_KNIGHT;
break;
case 7 :
variable = J_ROMING_KNIGHT;
break;
case 8 :
variable = J_PIECING_EYES;
break;
case 9 :
variable = J_WINDY_ROMER;
break;
case 10 :
variable = J_DESTROYER;
break;
case 11 :
variable = J_GUARDIAN;
break;
case 12 :
variable = J_PROPHECIER;
break;
case 13 :
variable = J_TRANSFORMER;
break;
case 14 :
variable = J_DEFENDER;
break;
case 15 :
variable = J_STRANGER;
break;
}
return( variable );
}
int AI_NPC_LoadScript( monsterCharacter_t* monster, char* filename )
{
FILE *fp;
int n, l, type, var, i;
char name[256];
fp = fopen( filename, "rb" );
if( !fp ) return 0;
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &type, sizeof( int ), 1, fp );
fread( &var, sizeof( int ), 1, fp );
monster->npcAi.aiVariable[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &var, sizeof( int ), 1, fp );
monster->npcAi.aiProcedureAddr[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
fread( monster->npcAi.aiData, n, 1, fp );
fclose( fp );
monster->npcAi.aiAddr = 0;
monster->npcAi.callProcedureAddr = 0;
monster->npcAi.isCall = false;
return 1;
}
char AI_NPC_GetCharData( playerCharacter_t* pc )
{
return( pc->npcAi.aiData [ pc->npcAi.aiAddr++ ] );
}
int AI_NPC_GetIntData( playerCharacter_t* pc )
{
int n;
memcpy( &n, &pc->npcAi.aiData[ pc->npcAi.aiAddr ], sizeof( int ) );
pc->npcAi.aiAddr += sizeof( int );
return( n );
}
int AI_NPC_Interpretor( playerCharacter_t* pc )
{
char inter;
if( pc->npcIdx == -1 ) return( false );
if( pc->npcAi.aiEvent == AI_NPC_WAIT ) return( false );
if( pc->npcAi.isCall )
{
pc->npcAi.isCall = false;
}
pc->npcAi.callProcedureAddr = pc->npcAi.aiAddr;
while( !pc->npcAi.isCall )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 'x' ) break;
switch( inter )
{
case 'p':
inter = AI_NPC_GetCharData( pc );
break;
case 'o':
AI_NPC_InterpretorOperation( pc );
break;
case 'i':
AI_NPC_InterpretorIF( pc );
break;
case 'c':
AI_NPC_InterpretorCall( pc );
break;
case 'f':
AI_NPC_InterpretorFunction( pc );
}
}
pc->npcAi.aiAddr = pc->npcAi.callProcedureAddr;
return(1);
}
void AI_NPC_InterpretorCall( playerCharacter_t* pc )
{
int paramAddr;
paramAddr = AI_NPC_GetCharData( pc );
if( pc->npcAi.isCall ) return;
pc->npcAi.callProcedureAddr = pc->npcAi.aiProcedureAddr[paramAddr];
pc->npcAi.isCall = true;
}
void AI_NPC_InterpretorOperation( playerCharacter_t* pc )
{
char inter;
int paramAddr1, paramAddr2, operatorParam;
int variable;
inter = AI_NPC_GetCharData( pc );
if( inter == 'v' )
{
paramAddr1 = AI_NPC_GetCharData( pc );
}
inter = AI_NPC_GetCharData( pc );
operatorParam = inter;
inter = AI_NPC_GetCharData( pc );
if( inter == 'v' )
{
paramAddr2 = AI_NPC_GetCharData( pc );
variable = pc->npcAi.aiVariable[paramAddr2];
}
if( inter == 'n' )
{
variable = AI_NPC_GetIntData( pc );
}
if( inter == 'f' )
{
variable = AI_NPC_InterpretorFunction( pc );
}
if( inter == 'd' )
{
paramAddr2 = AI_NPC_GetCharData( pc );
variable = AI_NPC_InterpretorDefine( pc, paramAddr2 );
}
switch( operatorParam )
{
case 0:
pc->npcAi.aiVariable[paramAddr1] += variable;
break;
case 1:
pc->npcAi.aiVariable[paramAddr1] -= variable;
break;
case 2:
pc->npcAi.aiVariable[paramAddr1] *= variable;
break;
case 3:
pc->npcAi.aiVariable[paramAddr1] /= variable;
break;
case 4:
pc->npcAi.aiVariable[paramAddr1] = variable;
break;
}
}
void AI_NPC_InterpretorParameter( playerCharacter_t* pc, int param[], int n )
{
char inter;
int variable, paramAddr;
int i;
for( i = 0; i < n; i ++ )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 'n' )
{
variable = AI_NPC_GetIntData( pc );
param[ i ] = variable;
continue;
}
if( inter == 'd' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable = AI_NPC_InterpretorDefine( pc, paramAddr );
param[ i ]= variable;
continue;
}
if( inter == 'v' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable = pc->npcAi.aiVariable[ paramAddr ];
param[ i ] = variable;
continue;
}
if( inter == 'f' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable = AI_NPC_InterpretorFunction( pc );
param[ i ] = variable;
continue;
}
}
}
int AI_NPC_InterpretorCase( playerCharacter_t* pc )
{
char inter;
int cases[5], casesNumber = 0;
int variable1, variable2, paramAddr, operatorAddr;
int i;
while( !pc->npcAi.isCall )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 't' ) break;
if( inter == 'a' ) inter = AI_NPC_GetCharData( pc );
if( inter == 'v' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable1 = pc->npcAi.aiVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable1 = AI_NPC_GetIntData( pc );
}
if( inter == 'd' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable1 = AI_NPC_InterpretorDefine( pc, paramAddr );
}
if( inter == 'f' )
{
variable1 = AI_NPC_InterpretorFunction( pc );
}
inter = AI_NPC_GetCharData( pc );
operatorAddr = inter;
inter = AI_NPC_GetCharData( pc );
if( inter == 'v' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable2 = pc->npcAi.aiVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable2 = AI_NPC_GetIntData( pc );
}
if( inter == 'd' )
{
paramAddr = AI_NPC_GetCharData( pc );
variable2 = AI_NPC_InterpretorDefine( pc, paramAddr );
}
if( inter == 'f' )
{
variable2 = AI_NPC_InterpretorFunction( pc );
}
cases[ casesNumber ] = 0;
switch( operatorAddr )
{
case 0:
if( variable1 == variable2 ) cases[ casesNumber ] = 1;
break;
case 1:
if( variable1 != variable2 ) cases[ casesNumber ] = 1;
break;
case 2:
if( variable1 < variable2 ) cases[ casesNumber ] = 1;
break;
case 3:
if( variable1 > variable2 ) cases[ casesNumber ] = 1;
break;
case 4:
if( variable1 <= variable2 ) cases[ casesNumber ] = 1;
break;
case 5:
if( variable1 >= variable2 ) cases[ casesNumber ] = 1;
break;
}
casesNumber ++;
}
for( i = 0; i < casesNumber; i ++ ) if( !cases[ i ] ) return( 0 );
return( 1 );
}
void AI_NPC_InterpretorThen( playerCharacter_t* pc, int addrInfo[] )
{
char inter;
pc->npcAi.aiAddr = addrInfo[0];
while( !pc->npcAi.isCall )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 'e' || inter == 'q' )
{
pc->npcAi.aiAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
AI_NPC_InterpretorOperation( pc );
break;
case 'i':
AI_NPC_InterpretorIF( pc );
break;
case 'c':
AI_NPC_InterpretorCall( pc );
break;
case 'f':
AI_NPC_InterpretorFunction( pc );
break;
}
}
}
void AI_NPC_InterpretorElse( playerCharacter_t* pc, int addrInfo[] )
{
char inter;
pc->npcAi.aiAddr = addrInfo[1];
while( !pc->npcAi.isCall )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 'q' )
{
pc->npcAi.aiAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
AI_NPC_InterpretorOperation( pc );
break;
case 'i':
AI_NPC_InterpretorIF( pc );
break;
case 'c':
AI_NPC_InterpretorCall( pc );
break;
case 'f':
AI_NPC_InterpretorFunction( pc );
break;
}
}
}
void AI_NPC_InterpretorIF( playerCharacter_t* pc )
{
char inter;
int addrInfo[3];
int cases;
addrInfo[0] = AI_NPC_GetIntData( pc );
addrInfo[1] = AI_NPC_GetIntData( pc );
addrInfo[2] = AI_NPC_GetIntData( pc );
while( !pc->npcAi.isCall )
{
inter = AI_NPC_GetCharData( pc );
if( inter == 'q' ) break;
if( inter == 'a' )
{
cases = AI_NPC_InterpretorCase( pc );
if( cases ) AI_NPC_InterpretorThen( pc, addrInfo );
else if( addrInfo[1] ) AI_NPC_InterpretorElse( pc, addrInfo );
else pc->npcAi.aiAddr = addrInfo[ 2 ];
}
}
}
| C++ |
#include "../global.h"
int PC_GetAttackComboType( playerCharacter_t *pc )
{
float dist;
int itemIdx, itemTableIdx, weaponType, classIdx, comboLevel;
if( pc->calAttackLength < DEFAULT_RANGE_ATTACK_LEGNTH )
{
pc->attackComboType = ATTACK_COMBO_TYPE_NOT;
itemIdx = pc->equipment[EQUIP_WEAPON_1 + pc->curWeapon];
if( itemIdx < 0 || pc->isTransform )
{
pc->attackComboType = ATTACK_COMBO_TYPE_NOT;
}
else
{
if( pc->level > 0 && pc->level <= 10 ) comboLevel = 0;
else if( pc->level >= 11 && pc->level <= 30 ) comboLevel = 1;
else comboLevel = 2;
itemTableIdx = pc->item[itemIdx].itemTableIdx;
classIdx = g_itemTable[itemTableIdx].classIdx;
weaponType = g_itemClassTable[classIdx].weaponType;
switch( weaponType )
{
case -1 :
pc->attackComboType = ATTACK_COMBO_TYPE_NOT;
break;
case WEAPON_TYPE_DANGGER :
pc->attackComboType = ATTACK_COMBO_TYPE_0 + comboLevel;
break;
case WEAPON_TYPE_ONEHAND_SWORD :
pc->attackComboType = ATTACK_COMBO_TYPE_0 + comboLevel;
break;
case WEAPON_TYPE_TWOHAND_SWORD :
pc->attackComboType = ATTACK_COMBO_TYPE_0 + comboLevel;
break;
case WEAPON_TYPE_MAGIC_BOW :
pc->attackComboType = ATTACK_COMBO_TYPE_NOT;
break;
case WEAPON_TYPE_STAFF :
pc->attackComboType = ATTACK_COMBO_TYPE_NOT;
break;
case WEAPON_TYPE_SPIRITOR :
pc->attackComboType = ATTACK_COMBO_TYPE_0 + comboLevel;
break;
case WEAPON_TYPE_CLAW :
pc->attackComboType = ATTACK_COMBO_TYPE_0 + comboLevel;
break;
}
}
if( pc->targetIdx < 0 || pc->targetType < 0 ) return( false );
return( true );
}
else
{
pc->attackComboType = ATTACK_COMBO_TYPE_RANGE;
if( pc->targetIdx < 0 || pc->targetType < 0 ) return( false );
dist = GTH_GetDistanceFromTarget( pc );
if( dist < 0.0000f ) return( false );
if( (int)pc->curSA - pc->atkBowSACost < 0 || dist < DEFAULT_MELEE_ATTACK_LENGTH )
{
pc->attackComboType = ATTACK_COMBO_TYPE_NEAR_RANGE;
}
return( true );
}
return( false );
}
int PC_IsValidRangeAttack( vec3_t playerPos, vec3_t monsterPos, int worldIdx )
{
vec3_t spos, dpos, sub, cpos, differ;
int localWorldIdx;
localWorldIdx = GTH_GetLocalWorldIdx( worldIdx );
vec_copy( playerPos, spos );
vec_copy( monsterPos, dpos );
vec_sub( dpos, spos, sub );
Normalize( sub );
sub[0] *= ZONE_GRIDSCALE;
sub[1] *= ZONE_GRIDSCALE;
sub[2] *= ZONE_GRIDSCALE;
vec_copy ( spos, cpos );
vec_sub( dpos, cpos, differ );
while( 1 )
{
if( vec_dot( cpos, differ ) < 0.0f ) break;
if( !AI_CheckCollision( cpos, &g_cmap[localWorldIdx] ) ) return 0;
vec_add( cpos, sub, cpos );
vec_sub( dpos, cpos, differ );
}
return 1;
}
int PC_IsValidAttack( playerCharacter_t* pc, int entityType, int entityIdx )
{
vec3_t spos, dpos;
float dist;
grid_t col;
int localWorldIdx;
if( entityType < 0 || entityIdx < 0 ) return( false );
if( entityType == ENTITY_PC )
{
return( true );
}
else
{
vec_copy( pc->position, spos );
vec_copy( g_monster[entityIdx].position, dpos );
}
localWorldIdx = GTH_GetLocalWorldIdx( pc->worldIdx );
AI_GetGridPosition( pc->position, col, &g_cmap[localWorldIdx] );
if( !AI_CheckCollision( col[0], col[1], &g_cmap[localWorldIdx] ) ) return( false );
dist = GTH_GetDistance2D( spos, dpos );
if( dist > DEFAULT_RANGE_ATTACK_LEGNTH )
{
return( PC_IsValidRangeAttack( spos, dpos, pc->worldIdx ) );
}
return( true );
}
| C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.